Record release evidence and coordinated integration work

This commit is contained in:
2026-09-10 11:13:11 -07:00
parent 7d1df4f369
commit b24a97360f
7 changed files with 324 additions and 0 deletions
+10
View File
@@ -1,5 +1,15 @@
# First release execution plan
**Active execution, 2026-09-10:** finish the already-started architecture palette
and inline naming with focused correctness checks, then perform actual native
basic-editing acceptance. In parallel, independently audit current behavior/
scenario workflows and remaining release requirements. Use concrete findings to
choose the next implementation; preserve the original first-release scope.
Root alone operates native UI and integrates shared files. Serialize Cargo jobs.
The renewed request authorizes Computer Use; older stop statements below are
historical. Current platform gates and final release acceptance remain required.
**Latest refinement:** consult actual installed Capella 7.1, replace the user-rejected horizontal creation/connection rows with a compact contextual palette and inline authoring, independently critique interaction risks, then build and verify the real workflow at wide/minimum sizes. [Benchmark and concrete acceptance](release-capella-basic-editing-20260907.md). Do not ship the rejected toolbar as the usability correction.
**Current priority (7 September):** the user's usability correction takes precedence over the advanced feature sequence below. Establish contextual named diagram creation, existing-element placement, basic editing and clear layer transitions, then verify them natively. Desktop checks were explicitly reauthorized. See [priority reset and acceptance](release-basic-editing-reset-20260907.md).
+50
View File
@@ -1,5 +1,55 @@
# Progress Ledger — first release
## Active continuation — 2026-09-10
Latest checkpoint (18:10 UTC, Codex-9e8r6t): palette compile repairs, bounded
inline naming, stale-submit retention and focused first-Escape cancellation are
implemented. Candidate 1 passed desktop 588/588; candidate 2 passed 22 focused
tests, GUI build, format and strict desktop Clippy. Candidate 2 native recovery,
focused Escape, first-submit Save As and complete Entity model/three exact
sources passed. Full basic editing/transition/reopen acceptance remains pending.
The user stopped Computer Use with physical Escape; native control is paused.
Source integration and packaging continue. See `release-palette-native-20260910.md`.
Two independent hosts cooperate in Gitea issue #1: this host is Codex-9e8r6t;
Codex-956atf owns process insertion, scenario clicked slots/reuse navigation and
typed stored-history forms. Exchange separate branches from `1797516`; do not
overwrite the shared continuation ref. Our later scenario layout work awaits
that source snapshot. Our release worker owns packaging/Docker/notice scripts;
our behavior worker independently reviews those changes. Cargo writers remain
serialized. Linux runtime is blocked by a verified supported WSL2 import failure
(`HCS_E_HYPERV_NOT_INSTALLED`); no repeated workaround is authorized by that fact.
The user has been asked for a viable Linux environment. This does not block the
remaining Windows/product work. The release is not accepted.
The renewed user objective is recorded in `PROJECT_GOAL.md` and attachment
`d3ddacce-6cca-47c5-9dd4-3d7cc2cfdba1/pasted-text.txt`. Continue to a complete,
usable OA/SA first release; the release is **not accepted**. Initial HEAD is
`1797516`, branch `codex/release1-continuation`, initially clean working tree.
Gitea issue #1, its comments and Wiki Home were read before resuming work.
The current user request authorizes native Computer Use verification. Older
Escape-hold statements below are historical. No Arcadia, Capella, Cargo, rustc
or QEMU process was running at this continuation's initial inventory. Root owns
native Windows operation, integration and the common ledgers. Current workers:
- `palette_finish`: architecture palette/inline naming repairs and the sole
initial Cargo writer lease; focused tests and a GUI build for native QA.
- `behavior_audit`: independent actual behavior/scenario workflow and semantic
gap review, with no GUI control or implementation changes.
- `release_audit`: fresh requirements, platform and release gate review;
read-only Linux readiness inspection, no VM launches or system changes.
Highest-value next actions: repair and verify the unfinished palette, exercise
real basic diagram editing against the existing independent fixture, act on
concrete behavior-workflow findings, then close current platform and release
acceptance gates. Historical Linux boot-workaround rejection remains recorded;
do not retry the denied action. Historical test counts do not establish current
acceptance. Meaningful progress is underway through repairs, independent review
and preparation of native model/source/history checks.
The sections below retain their original evidence scope and date.
**Checkpoint publication — 2026-09-10:** the user requested committing all current changes and pushing `codex/release1-continuation` to both `origin` and `gitea`. This is a work-in-progress snapshot. The interrupted palette-focused compilation failed with E0659 (ambiguous `column!` in `app/architecture_authoring/palette.rs:168`) and E0507 (moving the view out of an Arc in `diagram.rs:624`); an unnecessary-pattern-parentheses warning also remains in `architecture_authoring.rs:346`. The prior 584-test pass does not cover this newer palette revision. No Cargo/rustc process or local subagent was active at the publication preflight. Fix these errors and complete automated/native acceptance before packaging the redesign. Gitea coordination starts at issue #1 and the project Wiki; older evidence below retains its original scope.
**Latest priority checkpoint — Capella consultation and redesign:** the user rejected the large creation buttons and explicitly requested consulting the installed Capella. Native control resumed for that consultation in a disposable Capella 7.1 workspace. Actual palette, F2 rename and activity allocation were exercised; saved XML confirms allocation distinct from ownership. The horizontal creation/connection rows are being replaced with a compact expandable palette and inline naming. This supersedes the Escape hold and toolbar-fix proposal below. New implementation, native acceptance and a fresh user build remain pending. [Observed benchmark, alternatives and acceptance criteria](release-capella-basic-editing-20260907.md). The first-release goal remains active.
+20
View File
@@ -1,5 +1,25 @@
# Task Ledger — first release
**18:10 UTC checkpoint, 2026-09-10:** palette repair candidate 2 passes focused
tests/build/format/strict Clippy and native recovered-draft Escape/save plus the
complete Entity source oracle. The user stopped Computer Use; native verification
is paused with the rest of basic editing still unaccepted. Root publishes the
palette delta on a separate Gitea branch. Other-host process/scenario/forms source
is awaited; packaging implementation and independent adversarial review continue.
See the latest `STATE.md` section and dated reports for exact evidence and leases.
**Active objective, 2026-09-10:** the user renewed the complete first-release
request in `PROJECT_GOAL.md` and the latest pasted request. Native verification
and GPT-6 Astra worker delegation are explicitly requested. Initial repository
and Gitea evidence confirms an unfinished compact-palette redesign, including
two compile errors; prior native and automated passes remain historical.
The current hypothesis is that direct contextual authoring can make existing
OA/SA semantics approachable. Test that hypothesis against real engineering
tasks before claiming usability. Root owns integration/native operation and
ledgers; bounded palette, behavior-gap and release-readiness workers are active.
See the dated active section of `STATE.md` for exact ownership and next actions.
**Superseding user direction:** large horizontal creation buttons were rejected as intrusive and unprofessional. The user explicitly authorized consulting the installed Capella; that consultation has resumed and established actual compact palette, inline rename and explicit activity-allocation behavior. See [Capella 7.1 evidence and selected redesign](release-capella-basic-editing-20260907.md). The current candidate replaces creation/connection rows with one compact expandable palette and an in-place name editor. Native acceptance of the redesigned executable is pending; compactness is not assumed to prove usability. The earlier Escape hold and proposed toolbar-only correction below are superseded.
**Latest evidence:** basic editing full desktop584/584, bins, formatting and strictClippy passed. Native named Entity creation works at100%, but changing pending-toolbar height moves the screen placement22px. User Escape stopped the attempted Undo; native checks are paused again. Code-only toolbar correction proceeds. [Current findings](release-basic-editing-reset-20260907.md). The previous goal turn made concrete progress through implementation, integration gates and a native-discovered defect; this is not a no-progress blocker turn.
@@ -0,0 +1,102 @@
# Behavior workspace gap audit — 2026-09-10
Author: **Codex /root/behavior_audit**. Bounded investigation requested by root; no implementation, Cargo command, native input, shared-ledger edit or commit was performed. Owns this report only. Reviewed local `1797516f460ce27f7bc92e50ea2478ec51dd49b9` plus the working tree while the separate palette worker edited architecture files. Relevant behavior files were unchanged during inspection.
Read repository AGENTS.md, Gitea issue #1 and all then-current comments, open PR inventory (empty), and Wiki Home before review. The Wiki describes the older publication snapshot; the local commit above is this report's source baseline. Historical test/native records retain their original scope. **This is code/evidence review, not a fresh test pass or native acceptance.**
## Result
The existing Behavior workspace has real authoring capabilities. Rebuilding its domain from the older “static projection” audit would duplicate integrated work. The highest-priority remaining change is to make the **scenario workspace use an editable, remaining-height canvas with compact tools and contextual insertion**, then provide a local way to start a behavior. Native inspection of the current executable should confirm the resulting interaction priorities before implementation.
### Implemented functionality to preserve
| Area | Current evidence | Actual scope |
| --- | --- | --- |
| Process/functional chain | `behavior/topology.rs`, `topology/direct.rs`, `topology/view.rs`, `app/process_canvas.rs` | Existing work/exchange involvement, repeated source use with distinct occurrence IDs, Choice/Merge/Fork/Join/Loop, guarded links, link insertion and reconnection, same-column presentation reorder, legacy append/conversion, reusable definitions with expand/open/back. |
| Nested process instances | `topology/contextual.rs`, `topology/contextual_routing.rs`; `oa-core/src/model.rs:533–546` | Qualified occurrence paths, nested reusable instances and caller-owned Precedence/Exchange/CommonWork links are implemented in source7. The older statement that inner-chain linking is absent is stale. |
| Scenario | `behavior/scenario.rs:13–146, 988–1189, 1413–1901`; `behavior.rs:1477–1658` | Viewpoint-compatible lifelines, existing exchange reuse, click-click/drag message drawing at a captured sequence slot, paired call/reply, async/create/delete/timer messages, action/state observations, ALT/PAR/LOOP/OPT operands, explicit scenario-use lifeline bindings, same-parent reordering, execution bars, qualified payload values and exact interface-operation allocation. |
| State machine | `behavior/state_view.rs`, `state_canvas.rs`, `state_edit.rs`, `states.rs`; `app/state_diagram.rs` | Explicit state diagrams with persistent placements, nested regions, state/mode/pseudostate creation, move/pan/zoom/fit, transition draw/reconnect/details, typed time/change/signal events, work triggers and entry/do/exit work links. These are not static diagrams. |
| Shared editing boundary | `Document::execute`; typed `Command::Batch`; scenario tests at `scenario.rs:1963, 2646`; process tests at `topology/direct_tests.rs:126, 460`; state tests at `app/state_diagram_tests.rs:466, 504` | Existing tests exercise atomic history and exact model/source identity. REST accepts ordinary shared commands; no separate desktop-only semantic model is needed for the proposed UX work. Tests were inspected, not run in this audit. |
The native benchmark already operated Capella chain involvement/reference/control, repeated scenario call+reply/reference, and state/time-trigger workflows. The historical Studio direct-editing reports also contain bounded Linux/Windows trials. Preserve that evidence rather than calling everything unverified; it does **not** establish current full-release acceptance. See [Capella benchmark](release-capella-workflow-benchmark.md), [scenario editing](release-scenario-editing.md), [process editing](release-process-editing.md), and [source7 native acceptance](release-source7-native-acceptance-20260907.md).
Official Capella distinguishes global dataflow from contextual chain paths, and supports functional, exchange and interface scenarios plus state/function relationships. This supports the current separate occurrence and shared-definition identities; it does not require identical screen chrome. [Official feature description](https://mbse-capella.org/features.html). The source metamodel also defines distinct chain involvements, chain references, controls and sequence links. [Official FunctionalAnalysis model](https://raw.githubusercontent.com/eclipse-capella/capella/master/m2/plugins/org.polarsys.capella.core.data.def/model/FunctionalAnalysis.ecore).
## Ranked actionable findings
### 1. P1 usability — scenario authoring still gives the diagram a small fixed strip
**Evidence:** `behavior/scenario.rs:1435–1519` builds three tool rows and guidance above the diagram. At `1541–1545`, the canvas is capped at **180–340 px** normally and **110–190 px** while a form is open; a 700 px window receives 290 px normally and 110 px pending. The form fields separately receive 110–240 px at `1825`. The entire page still scrolls at `1839`, with a recursively expanded sequence-button list below at `1841–1901`. Scenario `CanvasEvent`/`State` at `75–91, 154–160` have no zoom, viewport or focus controls. This is a source-level layout limit, not a claim about measured pixels in the current native window.
**User task today:** draw a call in an ALT operand, fill its values and inspect the reply. The tool rows, small nested canvas and page/form scroll compete with that task. By contrast, process `topology/view.rs:270–375, 620–686` already has Tools/Selection shelves, focus, zoom and remaining-height panes.
**Proposed next change:** port the *layout pattern*, preserving scenario semantics. One compact header with owner, focus, Tools/Selection, Fit/100% and zoom; default closed shelf; independently scrolling tools/details; stable canvas occupying remaining height; independent pending form with always-visible Create/Cancel. Put the full sequence list in an optional outline shelf, not permanently beneath the canvas. Show only the active tool's concise guidance.
**Acceptance:** at 1440×900 and 1100×700, a four-lifeline ALT fixture remains usable with a pending call/value form, without scrolling the entire workspace to reach the canvas or actions. Use the process layout as the sizing baseline: actual remaining height, not constants derived from total window height. Opening/cancelling Tools, Selection and forms preserves the current canvas scroll position and manual scale. Focus expands the canvas and restoring panels returns the same selection. Fit is an explicit overview; it must not silently replace the working scale when choosing a tool. The diagram, form and outline scroll independently.
**Partition:** scenario view/layout helpers and scenario-specific state/events; narrow root-owned App/focus plumbing. No architecture palette files or core/schema edits.
### 2. P1 usability — behavior entry and creation are still routed through the global catalog
**Evidence:** `behavior.rs:691–728` creates one unsearched pick list of every same-layer process, chain, scenario and machine. The empty view at `711` only instructs “using Create element”. The actual creation catalog is `views.rs:128–162`, with all supported kinds and global At root/In selected operations. There is no New scenario/process/machine action in the behavior header, and scenario viewpoint is not part of a local startup action.
**User task today:** start the first OA process or a new SA interface scenario. The user must find the generic creator, choose a kind, choose ownership, then edit the owner/viewpoint before the specific tools become useful. A large list of existing behaviors is also hard to navigate by purpose.
**Proposed next change:** a compact New action with layer-correct Process/Functional chain, Scenario and State machine choices. Name and valid owner are explicit; scenario viewpoint is explicit in the same draft. Create selects and opens the new behavior; a machine can offer creation of its first view in the same validated operation. Provide searchable, named behavior navigation grouped by family, retaining UUID selection. Keep creation of an owner distinct from reuse/involvement of an existing one.
**Acceptance:** from a new project, create a named OA process and a named SA functional/interface scenario without using the generic kind catalog. Escape creates nothing; Create is one Undo step; Undo/Redo, source Apply and save/reopen retain IDs and viewpoint. Changing family/layer while the draft is pending follows existing draft guards. An engineer can find a named behavior among 100 mixed owners by search.
**Partition:** `behavior.rs` header plus a dedicated owner-creation module; root integrates App events and recovery. This can follow the scenario pane without touching architecture authoring.
### 3. P2 usability — form tools ignore the selected sequence position, and creation dominates editing
**Evidence:** `scenario::Event::Start` at `327–357` always sets `parent = owner`, `before = None`, and clears sender/source, regardless of the selected operand or occurrence. Only drawn messages use a captured `Slot` (`64–90`, `begin` near `278`). Toolbar Add Action/Observe state/Fragment/Reuse therefore start at the main scenario's end; the user must change the destination picker at `1581–1586`. `CanvasTool` has only Select and Message. Reorder explicitly rejects crossing operands at `636–661`. Generic properties can edit occurrence bodies and parent ownership (`forms.rs:1122–1178`); this is **not missing model capability**.
**User task today:** select an ALT operand and add an observed state, or add a third alternative and move an existing message into it. Selection does not seed the Add form. There is no scenario-local Edit occurrence/Add operand/Move to operand command, and no graphical fragment-creation slot tool. Existing properties/source workflows remain available but obscure the engineering operation.
**Proposed next change:** in Selection details, show the selected occurrence, represented source and owner/operand, with Edit, Add before/after, Add inside operand, Add operand for ALT/PAR, explicit Move to operand and Open referenced scenario. Seed the existing typed draft from this context. Keep ordinary drag reorder within the same parent; changing operands is an explicit validated operation. Expose scenario-reference Open in this shelf and retain a caller breadcrumb/back action as the process editor does. Defer free-form fragment rectangle drawing until these basic operations are usable.
**Acceptance:** selecting an operand and choosing Add Action defaults to that operand. Selecting a message and Add before records that exact ID as the insertion anchor. Add a third ALT operand without constructing a generic Occurrence manually. Move a call+reply pair explicitly into one operand in a single validated batch, preserving IDs and source exchange; reject moving only a reply if dominance becomes invalid. Reordering never silently reparents. Referenced-scenario navigation returns to the same caller occurrence.
**Partition:** scenario selection shelf/draft entry points and ordinary Batch planners, with production event tests. Root coordinates `behavior.rs`/App changes; no new domain records required.
### 4. P2 usability — missing shared sources produce a cancel-and-rebuild detour
**Evidence:** scenario lifeline/action/observation sources are existing model elements only (`672–703`); exchange choices are existing relations only (`704–771`); the no-match message ends with “or cancel” (`1380–1381`). In reuse, missing local lifelines produce “Add a compatible local lifeline before binding” (`1758–1762`), but the pending draft prevents starting another tool (`323–325`). Process `targets` at `topology.rs:326` also involves existing sources by design. The observed Capella message dialog offered creating a named exchange or reusing a compatible one; see the native benchmark's scenario section.
**User task today:** draw between two valid lifelines and discover no exchange, or reuse a scenario whose represented participant lacks a local lifeline. The first operation requires cancelling to author the shared exchange elsewhere. The second requires cancelling, adding a local lifeline, then rebuilding the use/bindings. This is a workflow gap, not a reason to invent exchanges automatically.
**Proposed next change:** first implement “Add missing local lifelines” inside a reuse draft with an explicit list and stable reserved IDs, committed together with ScenarioUse. For missing exchanges, either expose a named, endpoint-compatible Create exchange action or a draft-preserving Open source authoring/Return flow. The user must see the shared definition creation and choose it; keep existing reuse as the normal option. Reuse state/source pickers should also gain search/paging, since `picker` at `1333–1347` remains unbounded for those lists.
**Acceptance:** reuse into a caller with one missing compatible lifeline without losing its name or existing bindings; one Undo removes exactly the new lifeline and use. Invalid/ambiguous binding does not guess a participant. Creating a shared exchange plus its occurrence is explicit, uses the actual OA/SA endpoint contract and is one atomic command; cancelling creates neither. Existing exchange reuse never duplicates its definition.
**Partition:** scenario draft and planners first. Shared-exchange creation may reuse existing architecture planner services but requires a separate coordinated patch; do not couple it to the layout work.
### 5. P2 usability — state naming still follows the placeholder workflow rejected for architecture
**Evidence:** state `CreateAt` immediately creates `kind.label()` as the model name (`state_edit.rs:414–439`) and commits it through `app/state_diagram.rs:203–225`. State tools support move/transition and properties, but the only production F2 handler found is in architecture `diagram.rs:621`. Thus named-state creation still means creating “State”/“Region”, then editing properties. State geometry and semantics themselves are implemented.
**Proposed next change:** state/mode/region tool → valid owner/point → inline name → one Create+placement batch, with F2 on a selected named state/region and Escape cancelling the draft. Pseudostates may keep their conventional symbol names. This should follow the architecture naming contract while keeping its state-specific context and placement identity.
**Acceptance:** create named Standby and Operating in the selected region, cancel a third state without a model/history change, F2 rename Operating, then Undo/Redo and save/reopen. No camera shift, ownership change or architecture placement mutation occurs. State transition guards/triggers continue to use the existing details form.
**Partition:** state view/canvas/edit and root-owned state App routing; separate from scenario files and architecture palette.
## Semantic additions: separate release-scope decision
The above findings require no schema expansion. There is a narrower real difference worth recording separately: Capella InteractionFragment has explicit covered instance-role references; Studio `OccurrenceBody::Fragment` stores only operator and branch IDs (`oa-core/src/model.rs:582–589`). The current renderer derives a whole-sequence fragment presentation. Therefore the model cannot expressly declare a fragment covering only a subset of otherwise present lifelines. [Official Interaction model](https://raw.githubusercontent.com/eclipse-capella/capella/master/m2/plugins/org.polarsys.capella.core.data.def/model/Interaction.ecore), `InteractionFragment.coveredInstanceRoles` and `CombinedFragment`.
Do not disguise that difference with geometry alone or declare the current supported whole-scenario fragment invalid. If partial-lifeline behavior is required for release, its acceptance should be an ALT covering two of four lifelines with the other two continuing independently, preserved across graphical/source/REST edits and transitions. It needs a separately reviewed contract for coverage, order and call/reply dominance, references/deletion/remapping, grammar migration and rendering. Additional UML operator enumeration and timing constructs should not delay making the already implemented workflows usable without a concrete release task requiring them.
## Verification and next handoff
Root should operate the actual scenario workspace first, at 1440×900 and 1100×700, with an ALT operand and nested reuse fixture. Check the finite canvas, opening a pending message/value form, selection of an operand followed by Add Action, empty compatible-exchange result, reference Open, and return/navigation. These source-identified gaps are falsifiable observations, not a claim of a current native failure already witnessed by this agent.
For the first implementation slice, retain and extend the existing meaningful tests:
1. **Real Iced tree/layout:** keep the same canvas widget slot and actual scrollable state through shelf/form open/cancel, focus and owner changes. Existing seed: `scenario.rs:2476` and process `topology/direct_tests.rs:1015`; do not settle for counting widgets. Measure the canvas and fields at minimum/wide layouts, with Create/Cancel in view.
2. **Production input:** click-click and drag messages, reordering, scrolled origin, scaled coordinates, stale document/owner/revision/epoch, resize, bounds, Escape and focus cancellation. Zoom or shelf resize invalidates old gesture geometry; same-size passive events do not discard the working camera. Extend existing `behavior.rs` direct-pointer tests and `app/behavior_lifecycle_tests.rs`.
3. **Atomic semantic/source behavior:** preserve the current exact-ID call/reply pair, exact insertion order, branch dominance, unchanged shared source and one-entry Undo/Redo oracles (`scenario.rs:1963, 2015, 2060, 2646`). Test source-write rejection retaining every new draft value; source/JSON reopen agrees. A layout patch does not warrant new core semantics.
4. **Current-source acceptance:** rerun the focused affected tests, desktop checks/build and required formatting/lints under the sole Cargo owner's lease, then actual Windows native editing with Save/Undo/Redo/reopen. Linux runtime acceptance remains distinct. Do not transfer historical pass counts to newly changed code.
Recommended order: **scenario pane and selection context → local behavior creation → reuse completion → state naming**, with a small coherent native acceptance fixture after each slice. Root retains implementation assignments, integration and common Wiki/ledger updates. No release-complete claim follows from this report.
@@ -0,0 +1,82 @@
# Independent release readiness audit — 2026-09-10
**Post-audit Linux probe supersedes the readiness hypothesis below:** root subsequently authorized one isolated supported WSL2 import. It failed in 1.18 seconds with `HCS_E_HYPERV_NOT_INSTALLED`, despite the earlier `--status` omission. No Linux runtime, installation of packages, Cargo or GUI ran. See `release-wsl-readiness-20260910.md`. The reboot is a verified change; Linux VM creation remains blocked. The recommended next action is a viable external Linux runner or an externally corrected virtualization environment, without retrying denied QEMU modifications.
Codex `/root/release_audit`. Read-only product/source/platform inspection from HEAD `1797516`; the palette worker may change its owned files concurrently. Reviewed PROJECT_GOAL.md, AGENTS.md, current ledgers/coverage, Gitea issue #1 and comments, open PR list (none), Wiki Home and Branch-publication. Only this report is edited. No Cargo, GUI, import, VM, service launch, installation or system modification occurred. Code evidence below establishes implementation seams, not fresh runtime acceptance.
## Verdict and highest-value missing outcomes
The release is incomplete. The strongest next move is to complete a normal engineer's creation→allocation→OA/SA transition→save/reopen workflow on the current palette, then use the changed host state to establish Linux runtime access. Another broad semantic expansion is not currently justified by this audit. Historical absence findings for communication means, selective views, completeness warnings and source7 contextual links must not be carried forward as current gaps.
1. **P1 — Current basic editing is not accepted.** HEAD was published with two palette compilation errors, with repair/build owned by `palette_finish`. The previous 584-test pass and preview predate the current palette. Release acceptance must establish tool→point→inline name→Enter, Escape without a placeholder, F2 without duplicate history, existing-element placement, explicit allocation and understandable OA↔SA counterparts at normal and minimum dimensions. A compile fix alone does not answer the user's rejection of the earlier authoring workflow. Use the concrete acceptance in `release-capella-basic-editing-20260907.md`; the behavior auditor independently owns process/scenario criticism.
2. **P1 — Linux acceptance has a newly feasible path, but no current pass.** The host has rebooted since the failed import. Fresh WSL status no longer reports the old WSL2 virtualization error. No distribution is installed, so neither WSL2 execution nor WSLg rendering is proven. Corrected Linux server tests, current desktop rendering and actual file dialogs/history/reopening remain mandatory. Existing Linux core and cross-build evidence is valuable but scoped to older immutable snapshots.
3. **P1 — No coherent first-release distribution is ready.** The Windows preview is a development build of an older UI; Linux has no equivalent current final archive pipeline. CI uploads naked binaries. Release artifacts must contain matching optimized desktop/server, runtime inventory, complete examples, licenses/notices, usable documentation, source/toolchain provenance and archive hashes, then be exercised after extraction with development PATH assumptions removed.
4. **P2 — Onboarding still describes the rejected UI.** `guide.rs:190–191` tells beginners to use the Create toolbar, name first and choose position; current design is palette→point→inline name. This is a directly verified mismatch, not merely stale test totals. Update the built-in beginner tutorial and README against accepted controls, then follow the tutorial from Home using only its instructions. It must teach ownership versus allocation versus occurrence reuse and the meaning of a counterpart review.
## Current implementation and evidence boundaries
| User outcome | Current implementation inspected | What this audit can substantiate |
|---|---|---|
| OA and SA engineering model | Three Rust crates; typed Project/Command boundary. `model.rs` contains OA CommunicationMean, ExchangeCategory, contextual occurrence endpoints/purposes and explicit operation identity. `validation/coverage.rs` supplies advisory completeness checks. | The older missing-primitive list is superseded. Tests exist in `communication_means`, `coverage_diagnostics`, `source6_view_contract`, `source7_contract`, release capability/state/scenario/topology suites. No new execution here. |
| Graphical/source equivalence | `docs/language.rst`, parser/source project/updater, source identity/nested update tests and shared history. Source7 tests cover nested caller identities, operation direction/allocation, removal repair, reverse omission and migration. | Normative contract and executable checks are substantial. Full parity requires observing the final GUI transaction against complete model and authored source, including comments/modules and saved view state; a JSON serialization check alone is insufficient. |
| Bidirectional transitions and traceability | Shared counterpart/semantic review and source7 explicit reverse operation omission; typed artifacts with URI/revision/fragment. README/scope describe attachment, ordered and combined review controls. | Existing native records establish selected Windows histories/recovery/reopen paths. Remaining variants must be selected by changed behavior and high-impact failure paths, rather than declaring every GUI row absent or every old pass current. |
| Programmatic service | `oa-server` shares core; project/source bundle, query, transaction, transition and artifact routes; ETag-based atomic coupled storage. HTTP suites include `source7_contracts.rs`, source-project restart/conflict cases, communication limits and port-anchor persistence. | Recorded Windows server 56/56 and OpenAPI 72 fixtures/204 schemas/90 leaves are real bounded evidence. Linux corrected suite has not run. A deployment recipe and local transport suite do not establish a running systemd/container deployment. Public remote hosting is not itself required to prove deployability. |
| Offline guide/examples | Rust-owned searchable `guide.rs`, Home walkthrough resolution and `examples/release1` with 37 teaching/evidence files. `release1_teaching.rs` checks exact regeneration, identities, rejection and transition changes. | Guide exists and is offline; current beginner instructions drift. Packaged walkthrough lookup is independent of working directory, but only if staged beside the executable. |
## Concrete delivery defects rechecked in current files
These findings revalidate the earlier deployability report rather than assuming it still applies.
* `README.md:24–27` builds and runs optimized executables directly. `home.rs:50–51` enables repository fallback only with debug assertions; `home.rs:56–71` otherwise requires `examples/release1/project.arcadia` beside the executable. Cargo does not stage it. The documented optimized source-run workflow therefore cannot open its Home walkthrough on a fresh checkout. Add a reproducible stage step for the entire example and exercise that exact documented path.
* `deployment/Dockerfile.dockerignore` does not exclude `.local`, `.env*` or model-store data; the documented build uses repository-root context. These ignored-by-Git inputs include large development caches and disposable private QA material. Prefer an explicit context allowlist matching Dockerfile COPY inputs, then verify its inventory before an actual container build. No context transfer occurred in this audit.
* There is only `scripts/package-windows.ps1`; `.github/workflows/ci.yml:22–29` uploads executables without examples/notices. Linux staging/archive and runtime dependency documentation remain independent release work. The Docker runtime stage also copies only the server executable, so its redistributable notice policy needs closure.
* Windows packaging intentionally rejects unknown DLL imports, including VC redistributables (`package-windows.ps1:87–117`), whereas README recommends ordinary MSVC builds. Choose and actually verify static CRT or implement a documented redistributable strategy; do not weaken the import allowlist. This is an unresolved packaging recipe, not a newly observed MSVC link failure.
* `package-windows.ps1:124–137` copies repository README and only two harness reports. README links to STATE and native fixtures outside that closure. Ship a package-specific entry page or a bounded documentation closure, and check local Markdown links against extracted archive paths.
* `docs/server.md:3` still says schema 5 while the model/source is 7. README/scope link a 6 September “current” coverage report whose missing items were later implemented. Promote a concise current acceptance matrix instead of making the new engineer reconcile several contradictory chronological paragraphs.
* Both Git remotes are GitLab/Gitea; only GitHub Actions configuration exists. There is no evidence of an active runner on either configured host. The workflow follows stable and does not explicitly check declared Rust 1.90. Root should settle the supported runner/provider and compiler matrix before treating configured CI as a release gate.
## Changed Linux environment and exact supported next probe
Fresh read-only observations at this audit:
* Windows 11 Pro build 26200, VMware20,1; `LastBootUpTime = 2026-09-10T05:07:04.5-07:00`, HypervisorPresent true, total RAM approximately 8 GiB. The earlier pending-restart statement is historical.
* `wsl --version`: WSL 2.7.13.0, kernel 6.18.33.2-2, WSLg 1.0.73.2. `wsl --status`: default version 2 and a WSL1 optional-component warning; the old WSL2 virtualization failure text is absent. `wsl --list --verbose`: no installed distributions. This does not prove nested virtualization or GUI execution succeeds.
* Only `wslservice` was present among WSL/QEMU/Docker/Podman processes. Docker/Podman/SSH/QEMU were not found on the current PATH; task-local QEMU/cross-build assets remain. This is not a claim those programs are absent everywhere.
* One snapshot during the palette build had 2,692,384 KiB free RAM and 9,852,825,600 bytes free disk. Recheck before a new resource lease; do not concurrently start another compiler or memory-heavy guest.
The preserved official Ubuntu WSL image is `.local/linux-wsl/ubuntu-24.04.4-wsl-amd64.wsl`, **391,541,571 bytes** (about 373.4 MiB). Fresh SHA256 is **`9b2f7730dc68227dd04a9f3e5eab86ad85caf556b8606ad94f1f29ff5c4fd3f5`**, matching retained SHA256SUMS and the recorded HTTPS verification in `release-linux-validation-options.md:120`. The [Canonical release directory](https://releases.ubuntu.com/24.04.4/) identifies this exact WSL image. No new OpenPGP verification is claimed.
After the palette worker releases resources, root can verify the destination is absent and run one bounded supported import:
```powershell
wsl.exe --import ArcadiaLinuxQA C:\Users\User\Documents\Git\ARCADIA-Studio\.local\linux-wsl\ArcadiaLinuxQA C:\Users\User\Documents\Git\ARCADIA-Studio\.local\linux-wsl\ubuntu-24.04.4-wsl-amd64.wsl --version 2
wsl.exe --list --verbose
wsl.exe -d ArcadiaLinuxQA --exec /bin/sh -lc 'uname -a; cat /etc/os-release; df -h /; free -m; printf "%s\n" "$DISPLAY" "$WAYLAND_DISPLAY" "$XDG_RUNTIME_DIR"; ls -ld /mnt/wslg'
```
The import registers one task-named distro and creates its disk under the task directory; it is not purely a file extraction. Use a fresh name/path if either exists; do not overwrite/unregister an existing distro. Microsoft documents the [tar import command and WSL2 option](https://learn.microsoft.com/en-us/windows/wsl/use-custom-distro). The earlier local import failed before registration with `HCS_E_SERVICE_NOT_AVAILABLE`; the changed host justifies this supported probe, without retrying the rejected QEMU kernel workaround.
Resource estimates, not measurements: allow roughly 2 GiB for the base expanded distro, another 0.5–1.5 GiB for graphics/portal runtime packages, and preserve at least 5 GiB host free disk. A 5-minute import/bootstrap checkpoint should establish boot/readiness or produce a specific failure. Current free space is tight for an additional full native Rust dependency/target tree; prefer an existing ELF runtime probe before choosing native compilation or copying caches. Recheck actual `df`, installed package state and simulated package sizes before installation. Do not change global `.wslconfig` solely for this probe or terminate unrelated distributions.
### WSLg and the preserved cross-built GUI
The candidate `.local/cross-linux-qa/gui-runs/20260907T1025486926611Z/package/arcadia-studio` is 72,953,296 bytes, recorded SHA256 `330A3872D48EBF24AD21E6D4FA13CB6098BEBB3CB7FF82A2E082925CCF3DD346`. Its retained ELF inventory is x86-64 PIE, interpreter `/lib64/ld-linux-x86-64.so.2`, GLIBC requirements through 2.28, and only libc-family direct NEEDED entries. The package has all 37 lesson files. Retained status explicitly says runtime NOT RUN; this binary predates the new palette.
**Inference:** it is a plausible Ubuntu 24.04/WSLg runtime candidate. WSLg supports Linux X11/Wayland apps on WSL2 and is installed here; Iced enables both backends. [Microsoft GUI prerequisites](https://learn.microsoft.com/en-us/windows/wsl/tutorials/gui-apps) support the route, not success of this application. Start with `file`, `ldd`, exact hash readback and display/socket inspection in the imported distro. A successful `ldd` is insufficient: WGPU/winit load graphics/window libraries dynamically, and rfd needs working DBus/portal dialogs.
Inspect/install only missing runtime dependencies: X11/Xcursor/Xi/Xrandr/XKB, Wayland client/cursor/EGL, Vulkan loader and Mesa Vulkan drivers, plus a session bus and xdg-desktop-portal with a working backend for file dialogs. Use the exact installed lavapipe ICD path when testing software Vulkan, for example `WGPU_BACKEND=vulkan VK_DRIVER_FILES=/usr/share/vulkan/icd.d/lvp_icd.x86_64.json`, after verifying the file exists. No full Linux desktop environment is needed just to use WSLg. Copy the entire package into the guest for local-filesystem Save/reopen tests; preserve the snapshot and hash. A passed old-ELF launch would discharge only environment viability. Rebuild current source and rerun acceptance for release. Record whether X11 or Wayland was exercised; do not claim both from one launch.
## Verification strategy on the final integrated candidate
1. **Windows authoring first.** Root serializes Cargo after repair; focused architecture tests followed by `cargo test --locked -p oa-desktop --bin arcadia-studio -- --test-threads=1`, formatting and strict Clippy. Freeze source and binary hash before native work. Run the basic editing story, current behavior fixes and tutorial at normal/minimum dimensions. Capture full model/source before/after, Undo/Redo equality, save/reopen and representative cancellation/invalid-draft recovery. Do not count screenshots alone as persistence proof.
2. **Shared semantics and HTTP.** Run `cargo test --locked -p oa-core --all-targets -- --test-threads=1` and `cargo test --locked -p oa-server --all-targets -- --test-threads=1` on the candidate, plus `crates/oa-server/tests/semantic_schema.py --check --validate`. Strictly render both reST specifications and compare generated HTML. Verify teaching regeneration and full multi-file examples without mutating historical oracles. Run same core/server commands under explicit Rust 1.90 on Linux when capacity permits. Corrected HTTP preparation-phase test must pass on Linux with unchanged production deadline/assertions; no load-dependent weakening.
3. **One parity story across all surfaces.** In a commented source bundle create OA participants/activities, interaction and communication means; allocate explicitly; derive/review SA boundary/functions; add typed operation/scenario and a reused process occurrence; attach an artifact. Modify graphically, edit source, apply an equivalent REST transaction, fetch through desktop, then reject stale ETag and structurally invalid edits without changing accepted model/source/disk. Restart the actual service and compare the coupled envelope. This tests integration of existing semantics rather than adding new primitives.
4. **Actual Linux app and service.** After WSL bootstrap, execute current optimized Linux desktop through WSLg and service against an isolated local guest data directory. Include native open/save dialogs, Unicode/path-with-spaces, multi-file source, counterpart review, direct behavior edit, Undo/reopen and minimum-window selection. Exercise configured authentication, process lock, restart and backup/restore per server docs. WSLg is real Linux user-space runtime evidence with a specifically named display environment, not evidence of every Linux GPU/session.
5. **Release artifacts and independent closure.** Run `cargo fmt --all -- --check`, `cargo clippy --locked --workspace --all-targets -- -D warnings`, workspace tests and `cargo build --release --locked --workspace --bins` with recorded target/compiler. Package Windows/Linux and the documented server deployment path. Verify clean extraction, executable equality, runtime libraries, complete lessons, notices, relative links and checksums. Have a fresh reviewer use the final matrix and produced artifacts; close material findings. Keep logs tied to source/binary hashes and avoid aggregating historical reruns into a misleading single green total.
## Root decisions required
* Assign the next exclusive resource lease to bounded WSL import/readiness after palette compilation; decide native Linux compilation only after actual disk/RAM measurements. If supported import still fails, retain its precise error and request a viable Linux runner instead of revisiting denied boot modifications.
* Select and document Windows distribution toolchain/CRT and Linux runtime baseline. The existing GNU/LLVM preview path and Ubuntu 24.04 acceptance basis are reasonable candidates, not proof of optimized MSVC/all-Linux support.
* Assign small packaging/docs corrections independently of semantic implementation, and choose an actually active CI provider. These are reversible engineering choices; no user scope relaxation is needed.
* Keep first-release OA/SA acceptance broad enough to answer the user's workflows. This audit found no reason to introduce LA/PA, simulation or Capella file compatibility; equally, it found no basis to relabel current native/platform/delivery gates as optional merely because semantics and test volume are extensive.
@@ -0,0 +1,27 @@
# Scenario workspace — 2026-09-10
Owner: **Codex-9e8r6t /root/behavior_audit**. Root assigned the bounded layout slice after [the source audit](release-behavior-gap-audit-20260910.md). Scope is the scenario canvas, compact shelves, focus and independently scrollable form. Existing semantics, source grammar, REST commands and raw-draft recovery remain authoritative. No owner creation, missing-source creation, reuse semantics, state naming or commits/pushes are included.
## Coordination and current status
**Design only; production remains unchanged.** Palette_finish released its source freeze after desktop588/build/fmt/Clippy and returned Cargo to root. Separately, Codex-956atf owns the clicked-slot Action/Observation/Reuse/Fragment work on another host. Root is coordinating its patch before this layout starts; this report does not supersede that ownership. Do not launch Cargo without root's sole-writer lease. Root owns real native QA and common ledgers/Wiki.
## Bounded implementation design
1. Integrate the other host's clicked-slot work first. Then move the existing scenario view/outline to `behavior/scenario/workspace.rs`, leaving its updated draft/planner/event semantics in `scenario.rs`. Keep the extracted fields/forms behavior unchanged before replacing its outer layout.
2. Use a compact stable header for owner, focus and shelf/camera actions. Tools and Selection are disclosures; place the existing sequence outline inside a scrolling shelf rather than beneath the diagram. Default shelves closed. Active-tool guidance is concise and always visible.
3. Keep a fixed widget-tree slot for the closed shelf (`Column::from_vec`; a zero-height child must not disappear). Allocate header and shelf once, then divide actual remaining height between the canvas and pending editor. Keep both canvas and form slots stable when the form opens/closes. Fields scroll independently; Create/Cancel remain outside the field scroller. No enclosing page scrollable.
4. Extend the existing process focus layout slot in `views.rs` to scenarios without moving the main workspace in the widget tree. Focus must retain selection, canvas state and raw draft. Coordinate any App change with root.
5. Evaluate measured viewport Fit/manual scale against actual Scene geometry. Existing Scene draws with `scale` and transforms pointer positions by that scale. If included, get viewport size from a sensor around the actual canvas scrollable, accept passive viewport changes under document/owner/revision guards, and invalidate old pointer epochs on geometry/scale changes. Use a readable default of 100%; tool changes must not force another scale. A Fit overview must be explicit, and limited overview scale must be disclosed. Do not infer available height from total window size.
## Planned verification
- Use the exact generic production pane builders with real Iced layout and scroll operations at minimum/wide center-pane sizes, with short/wrapped headers, open/closed shelves, pending forms and focused widths. Assert all canvas/action/field rectangles lie within the actual parent allocation; assert remaining space grows with the viewport.
- Establish real canvas/form scroll offsets, then diff across shelves, form open/cancel, focus and resize. Verify stable widget state and independent scrolling, not just widget counts. Full App tree-diff tests also preserve selected UUID, raw behavior recovery snapshot and the accepted document Arc.
- If camera controls are included, test default/manual/Fit against the scene bounds and measured viewport; finite inputs only; correct same-size notifications; stale context rejection; production click-click, drag and reorder at multiple scales with nonzero scroll origins.
- Retain existing scenario paired-call/branch/reorder/source/Undo/Redo/recovery tests. New geometry events remain passive during async saves and modal guards; drawing continues to reject pending source/properties/behavior edits.
- Root-owned native before/after task at 1440×900 and 1100×700: draw into a visible ALT operand, open a message/value form, scroll fields, reach Create/Cancel, open/close shelves and Focus, then Save/Undo/Redo/reopen. Actual Windows and Linux acceptance remain separate from unit/build results.
## Evidence
No implementation checks or native acceptance have run for this slice yet. Palette588 is an upstream snapshot gate, not a scenario-workspace test pass. Append exact edits, commands, results, binary identity and unresolved acceptance after implementation.
+33
View File
@@ -0,0 +1,33 @@
# Supported WSL2 readiness probe — 2026-09-10
Codex `/root/release_audit`. Root explicitly authorized one isolated supported WSL2 import after the release audit identified the host reboot. No current native Linux release acceptance is claimed.
## Authorization and preflight
Owned distro name `ArcadiaStudio-Release1-20260910`; destination `C:\Users\User\Documents\Git\ARCADIA-Studio\.local\linux-wsl\release1-20260910`. Both absent before action. The preflight required at least 8 GiB host free disk and 3 GiB available RAM; actual values were 9,648,353,280 bytes and 4,208,900 KiB. No compiler, global WSL setting, Windows feature, host restart, QEMU launch, distro unregister or GUI control was authorized or performed. Root retained GUI ownership.
The verified Canonical archive is `.local/linux-wsl/ubuntu-24.04.4-wsl-amd64.wsl`, 391,541,571 bytes, fresh SHA256 `9b2f7730dc68227dd04a9f3e5eab86ad85caf556b8606ad94f1f29ff5c4fd3f5`. This matches the retained HTTPS release checksum; no OpenPGP claim. Current WSL version 2.7.13.0, kernel 6.18.33.2-2 and WSLg 1.0.73.2 were read; Windows reboot time was 2026-09-10 05:07:04.5 -07:00. Earlier `wsl --status` omitted its historical WSL2 virtualization warning, but this was only a hypothesis of readiness.
## Exact action and outcome
```powershell
wsl.exe --import ArcadiaStudio-Release1-20260910 C:\Users\User\Documents\Git\ARCADIA-Studio\.local\linux-wsl\release1-20260910 C:\Users\User\Documents\Git\ARCADIA-Studio\.local\linux-wsl\ubuntu-24.04.4-wsl-amd64.wsl --version 2
```
One attempt completed at **2026-09-10T17:38:44.5529693Z**, elapsed **1.177154 seconds**, exit **-1**. Terminal error:
```text
Wsl/Service/RegisterDistro/CreateVm/HCS/HCS_E_HYPERV_NOT_INSTALLED
```
WSL says virtualization is not enabled and asks for the Virtual Machine Platform component and firmware virtualization. This establishes that actual VM creation remains unavailable. It does not identify whether Windows optional features or the VMware host's nested virtualization is the underlying cause. HypervisorPresent alone did not establish nested VM support. No second attempt or setting change occurred.
The readiness chain stopped before a shell: no `uname`, guest OS inspection, WSLg display/socket check, apt installation, Linux GUI, service, Rust build or test ran. No process was started that requires distro shutdown. The root was immediately informed of the failure.
Raw task-local evidence is under `.local/linux-wsl/readiness-20260910/`: `preflight.json`, `import.log`, `import-status.json`, `post-import-list.txt`, `post-attempt.json`. At 17:39:46 UTC the list still said no distributions were installed and the task install directory was absent; no deletion was needed or performed. Host free disk was 9,647,493,120 bytes and available RAM 4,218,664 KiB.
## Handoff
The preserved source7 ELF/package remains unchanged and unexecuted. Its path, hash, runtime prerequisites, WSLg inference and a candidate launch environment are in `release-readiness-audit-20260910.md`. There is currently **no executable GUI launch command against this distro**, because the distro was not created. Do not present an old cross-build or installed WSLg version as runtime proof.
Next: provide a viable Linux runner or correct the external virtualization prerequisite, then take a fresh bounded readiness decision. The isolated supported import was distinct from the earlier automatically rejected QEMU timer workaround; that workaround remains untouched. Windows authoring, documentation/packaging corrections and release validation can proceed independently. Current-tree Linux runtime/server gates remain open.