ARCADIA-Studio/harness/release-capella-workflow-benchmark.md

Original Capella workflow benchmark — resumed, 2026-09-05

Status: incomplete. This record contains only actual observed UI behavior. The six requested capability, chain, scenario, state, data/interface and everyday-workflow comparisons have not been completed. The source/schema investigation remains separately recorded in release-semantics-audit.md; it is not a substitute for this runtime benchmark.

Observed native UI

Original Capella 7.0.1 was restored from its minimized window. The open IFE sample displayed [OAB] All Operational Activities and Entities at 2560×1392. The screenshot showed Passenger, Aircraft, Crew, Personal Device, Ground Operator and Airline Company containers. Pilot and Cabin Crew nested inside Crew; their operational activities nested inside their participant boxes. Activities remained connected by named interactions crossing container boundaries. Selecting a path highlighted its activity boxes and connecting arrows in blue without discarding surrounding context.

The right palette grouped tools by Entities, Roles, Activities, Accelerators and Common. Visible tools included Operational Entity/Actor, Communication Mean, Role, Manage Role Allocation, Operational Activity, Interaction, Manage Activity Allocation, Activities from Mode/State, Elements from Scenario, Constraint and applied property-value groups. This is concrete evidence for contextual grouped authoring, explicit allocation operations and semantic insertion accelerators. It does not prove that any creation tool was exercised.

The bottom Semantic Browser followed the selected Broadcast Movies operational activity. Its three columns exposed referencing elements, the current element and referenced elements. Actual entries included Allocating Entity; Incoming Interactions; Operational Processes; four Realizing System Functions; Scenarios; Parent; All Related Diagrams; All Related Tables; Active in States (Cruising and Takeoff); and Outgoing Interactions. The browser toolbar offered Back/Forward, diagram visibility, limited expansion, sorting, follow-selection and requirements options. Several related diagrams and the System Functions–Operational Activities table were discoverable from this one selection.

Release acceptance tasks justified by these observations:

• Select a nested leaf and immediately see its performer, incoming/outgoing exchanges, process/scenario uses, active states, counterparts and related diagrams with navigation in both directions.
• Create or insert appropriate objects using task-grouped controls close to the current view; keep containment, allocation and diagram insertion distinct.
• Navigate from a selected activity through a realization and back, preserving view context; provide visible relationship names rather than unexplained endpoint-ID lists.
• Highlight a selected engineering path while retaining readable surrounding architecture.

These are observed-control comparisons, not a claim that the current Studio passes them.

Interruption and recovery evidence

Selecting the project and issuing Explorer Ctrl+C/Ctrl+V to make a disposable copy left the original main window marked disabled. Repeated window inventories exposed no copy modal. Escape and one explicit activation/re-observation did not reveal a recoverable dialog. No original model edit or save was performed. The original .metadata/.log had no new entry from this attempt; its last entries were older transition class-loading messages, so they do not explain this behavior.

A separate Capella process was launched using a separate workspace. A filesystem copy of the sample was prepared without changing the original. The new process displayed Welcome and opened the Import wizard with General, Capella Example, Git, Install, Tasks and Team categories. The sample has not been imported into the new workspace yet.

Some state captures for the Capella target displayed pixels from a foreground application instead. Those mismatched captures were not used for input. Explicit activation and re-observation restored visible Capella. The next attempted import-category click returned: Computer Use was stopped by the user with the physical Escape key. All CUA stopped immediately. Further native input requires fresh user steering.

Historical continuation handles (superseded by resumed checkpoint below)

• Original executable: C:/Users/sorok/Downloads/capella-7.0.1.202503211540-win32-win32-x86_64/capella/capellac.exe.
• Original window: 3673208; original workspace: D:/CodexBuilds/Capella2-v2-01a06e2e/capella-workspace.
• Separate benchmark window: 2035890, title capella-workspace - Capella; launch exec session: 75759.
• Separate workspace: D:/CodexBuilds/Capella2-release1-01a06e2e/capella-workspace.
• Disposable sample copy: D:/CodexBuilds/Capella2-release1-01a06e2e/capella-sample-source/In-Flight Entertainment System.
• Last new-process UI: Import wizard, not yet completed.

Screenshots were captured and visually inspected through native Computer Use outputs in this task. No screenshot files were saved and no completed six-workflow benchmark is claimed. No Studio source changes or builds were part of this interrupted UI investigation.

Resumed native benchmark — 2026-09-05, ongoing

Computer Use works after the desktop update. Fresh inventory had no Capella. Launched the existing executable with the isolated release workspace (exec session 55359, window 524804), imported the already prepared disposable IFE source using File > Import > General > Existing Projects into Workspace, and loaded its AIRD. The source is the disposable copy, not the original workspace.

Mission/capability authoring (performed)

From the System Analysis workflow, expanded Define Actors, Missions and Capabilities. It offers automatic OA-capability transition, contextual System Actor creation from OA participants, contextual Capability or Mission creation from OA capability, contextual actor diagram, mission/capability map and participant traceability matrix. Created [MCB] Studio benchmark through the mission/capability map command. The diagram palette separately exposes Actor, Mission, Capability; Capability Exploitation, Involved Actor, Extends, Includes, Generalization; and existing-element insertion tools Capabilities, Missions, Relationships, Actors.

Actually created a Mission and Capability with palette then canvas position. The property dialog exposed capability pre/postconditions, inheritance, involved functions/chains, available states/modes, realized capabilities and involved components. Renamed the new capability Deliver safe entertainment. Existing-capability insertion opened a searchable available/selected tree chooser; double-clicking Integrate Aircraft Constraints transferred it to selected, and OK inserted a placement of that existing object. Created Includes by palette > source capability > target capability, then Capability Exploitation by palette > mission > capability. Both links appeared and selection identified Abstract Capability Include and Capability Exploitation respectively in Properties and semantic path.

Friction: plain Mission 6/Capability 14 defaults require a follow-up rename. The dark theme renders nearly black external names and edges on dark gray, making engineering content much less readable than the palette. Large representation/property chrome consumes substantial room. Useful behavior to preserve: view-specific creation, explicit insertion versus semantic creation, endpoint tools with compatible-target feedback, and capability-level semantic involvement editing.

Functional-chain involvement and control (performed)

Opened [SFCD] Resume VOD Movie using the SA diagram viewer's Functional Chain Description category. The view contains function involvements, including actor functions in blue and system functions in green, connected by functional-exchange involvements. Palette Involvements includes Function, Exchange, Exchange and Function, Functional Chain and Connect Functions; Sequencing includes AND/OR/IT controls, corresponding construct accelerators, Sequence Link, Function on Sequence Link, Exchange with Sequence Link and Exchange from Sequence Link.

Actually inserted an existing Broadcast Audio Announcement chain through Functional Chain > canvas > filtered same-layer chain chooser > OK. Capella created a Functional Chain Reference, rendered as a titled nested container with the reused chain's inner functions. Resizing that container revealed more nested content rather than copying the source functions. Added an OR control and connected an existing Watch Video on Private Screen involvement to it with a Sequence Link. The selected link has a distinct Condition field and Links reference field. The control has explicit OR/AND/ITERATE kinds. Thus functional exchange semantics and contextual precedence are separately authored, and chain reuse is a reference with nested visualization.

Release acceptance derived from this direct operation: insert existing work/exchange/chain from a contextual picker; create a branch control and guarded precedence without inventing a global functional exchange; visibly distinguish actual referenced work from its involvement; open/expand a reusable chain by identity; permit diagram geometry changes independently of semantic reuse. These observations do not establish that Studio currently passes the workflows.

Scenario messages and reuse (performed)

Opened [FS] Perform Audio Announcement from the SA workflow's Function Scenario category. Four lifelines represent named actor/system functions, with exchange messages, execution bars and explanatory notes. The palette offers System Function, existing Functions, Functional Exchange with return branch, Functional Exchange, Reference, LOOP variants, Operand, Involved State/Mode, Duration and Exchange Context.

Actually used Reference by dragging across the four lifelines. The chooser offered two other Function Scenarios, filtered to the appropriate scenario type. Selected Determine Passenger Service Availability. The result is a ref region with its target name; Properties identifies a Use/Interaction Use with Covered Instance Roles and Referenced Scenario. No explicit role-correspondence dialog appeared in this operation. Right-clicking that reference > Open > its named scenario opened the referenced scenario in another tab. This is actual reference navigation, not only a visible menu item.

In the target scenario, chose Functional Exchange with return branch and clicked Select Passenger Service then Handle Service Activation Requests. The Create a Message dialog offered either a new named exchange or the compatible existing PassengerVODServiceSelection exchange with those endpoints. Chose the existing exchange. Capella created an additional call occurrence, dashed return branch and receiver execution bar, while preserving the original occurrence higher in the scenario. The new call's Properties shows the invoked exchange and explicit SYNCHRONOUS_CALL kind, with alternatives ASYNCHRONOUS_CALL, REPLY, CREATE, DELETE and TIMER. The observed workflow reuses the model exchange while creating scenario-specific occurrences.

Concrete Studio acceptance: create a message by choosing visible lifeline endpoints and an endpoint-compatible exchange; offer a call-and-reply action with paired occurrences; allow the same exchange more than once; render readable message names and execution spans; create a named scenario-reference region and open its target without losing the calling view. References and message occurrences need explicit semantic identity. ALT/LOOP operand creation, durations, exchange contexts and transition correspondences were not exercised in this pass.

States, regions and event triggers (performed subset)

Opened [MSM] IFE Operating Modes. The sample includes Initial, Choice, Final, ordinary modes and a composite Maintenance mode containing Region 1 and nested modes. The palette exposes Mode, State, Region, Initial, Join, Choice, Fork, Terminate, Final, Deep History, Shallow History and Transition. Created a Deep History H* node by clicking inside Maintenance's region; its semantic path confirms that region owns it. A subsequent attempt to connect it to Sustaining did not produce a visible edge; the cause was not diagnosed, and no successful history fallback is claimed.

Opened the existing Choice-to-Content Management transition's property dialog. It exposes Guard, Effects, realizations and a Triggers list containing Load Digital Media with a function icon. Added a Time Event using the trigger clock button, selected AFTER, opened its Opaque Expression editor, and entered 30 s in the LinkedText body. After accepting the expression, event and transition dialogs, the trigger list displayed both Load Digital Media and [AFTER]30 s. The selected Time Event properties also showed the expression and AFTER kind. Thus this observed trigger set can refer to an involved function as well as an explicit timed event.

Useful behavior: container-based region ownership; recognizable pseudostate glyphs; transition-local guard/effect/trigger authoring; typed relative and absolute time-event choices. Friction: adding a short relative delay required three nested dialogs, and the updated edge label clipped the combined triggers. Studio acceptance is a concise transition editor supporting semantic trigger references, typed timed events and readable labels, with a clear region destination when adding state nodes. Change-event creation, full transition validity, orthogonal regions and history execution remain untested here.

Data, interfaces and allocation (performed subset)

Opened [CDB] In-Flight Entertainment Dictionary. Existing classes render properties inside their class boxes, associations carry role names and multiplicities, and an enumeration shows its BUSINESS/PREMIUM/ECONOMY literals. The sample's own note says this particular dictionary is conceptual and is not connected to its functional analysis; that note is a sample limitation, not a Capella capability limitation.

Created Interface 1 with the Interface palette tool. Interface Properties exposes visibility, a Super reference and allocated Exchange Items. Expanded the exchange-item creation variants: Event, Operation, Flow, Data and Undefined Exchange Item. Chose Operation and clicked the canvas, creating ExchangeItem 1; Properties confirms Exchange Mechanism OPERATION, alternatives EVENT/FLOW/SHARED_DATA, abstract/final flags, Super and Exchange Item Elements.

Used Manage Exchange Item Allocations, clicked the interface, and selected the existing ExchangeItem 1 in the familiar available/selected tree picker. After OK, the interface displays ExchangeItem 1 as an internal row while the separately placed exchange-item object remains visible. Selecting the internal row identifies a distinct Exchange Item Allocation pointing to the item. Its Properties include Transmission Protocol (unset, synchronous, asynchronous, unicast, multicast, broadcast) and Acquisition Protocol (unset, read, accept). This is direct evidence for representing an allocation by nesting rather than a noisy edge, without confusing it with semantic containment of the allocated item.

Studio acceptance: create an exchange item with an explicit mechanism, allocate it to an interface from a compatible-object picker, show the allocation as a nested named row, preserve the item identity across placements, and edit allocation-specific protocols separately from the item definition. Property typing/ranges/defaults/multiplicity edits, interface exchange realization, and exchange-category operations remain untested in this native pass.

Everyday navigation and representation operations (performed subset)

The task-oriented workflow page and type-grouped diagram viewer were used repeatedly to locate and open MCB, SFCD, FS, MSM and CDB representations. Existing-object insertion consistently uses a searchable available/selected picker with tree/list display and semantic paths. The scenario-reference Open command was used successfully. A reused-chain container was resized to reveal nested content without changing the referenced model object.

Pressed F9 on the newly created exchange-item allocation. Semantic Browser opened three panes: Referencing Elements; Current Element (including Parent = Interface 1 and All Related Diagrams = the CDB); and Referenced Elements (Exchange Item = ExchangeItem 1). This gives a navigable explanation of an allocation's owner, target and representations instead of only an opaque edge. The previously inspected scenario-reference context menu additionally exposes Show in Project Explorer (F8), Show in Semantic Browser (F9), Show Related Elements, Impact Analysis, Show/Hide, Layout, Reset Origin, Validate, Allocation Management and mass-editing/visualization actions. Except for F9 and Open, these menu actions were observed rather than executed in this resumed pass.

Checkpoint and remaining comparison work

This pass materially advanced all five engineering feature comparisons with actual creation/editing, and exercised a subset of navigation; it is still not a completed six-area benchmark. Remaining direct comparisons include participant/include/extend variants; complete AND/OR/iterate branch topology; OA process equivalents; scenario operands/context/correspondences; state transition edge cases; data properties and categories; show/hide/selection productivity; and a current transition-preview round trip. Controls merely seen in a palette are distinguished from successfully operated controls above. No conclusions about Studio passing these acceptance workflows are implied.

CUA handed back to the lead for Studio verification. Original Capella remains open, window 524804, launch exec session 55359, maximized at 2560x1392. The active tab is the CDB with the allocation selected and Semantic Browser visible; other edited benchmark diagrams remain open. Changes are unsaved in the disposable sample. Re-inventory windows before future input; these are continuation hints, not durable identities. All screenshots were captured and inspected through the native Computer Use tool; no screenshot files were saved. No Studio code or build was changed by this benchmark agent.

System architecture and actual port authoring (lead, 2026-09-05)

Reopened the SA workflow and [SAB] High Level System Overview with some FCs. Aircraft, IFE System, Passenger and Cabin Crew are nested participant containers; allocated green functions sit inside them, and italic parent functions summarize their allocated descendants. Functional exchanges attach to small function-boundary ports. This reinforced the distinction between direct work allocation and inferred summary nesting.

Opened Send Audio Announcement's FunctionOutputPort FOP5 properties: Outgoing Exchange Items and Realized Function Output Ports are explicit fields; it has no generic InOut/function-interface contract. Created FunctionalExchange38 by choosing the palette tool then Provide Navigation Data and Determine Operating Profiles. Capella created source FOP1 and target FIP3 automatically; Semantic Browser identified their actual function owners and FE endpoint references. Modeling Accelerators separately offers Propagate Port Realizations, Propagate Exchange Items to Function Ports and Synchronize Exchange Items and Function Ports. Those accelerators were observed, not run. Allocation Management opened an empty component-exchange chooser and was cancelled.

Created C1 with Component Exchange between Aircraft and IFE System. Capella automatically created their ComponentPorts. The tool's tooltip requires matching port kinds and complementary Flow orientations. Source CP1 properties show Standard/Flow, Unset/In/Out/InOut, Provided Interfaces, Required Interfaces, Allocated Ports and Realized Ports. The generated source is Flow/Out. Opened its Allocated Ports picker: available function ports belong to functions assigned to Aircraft (including the newly created Provide Navigation Data FOP1). No allocation was committed; the picker remains pending. Screenshot identity/foreground errors interrupted further input, so component-exchange generation accelerators and allocation completion are not claimed.

The adopted Studio port contract uses separate typed function and component variants, mandatory FE endpoints, independently oriented component exchanges, explicit port allocations and preserved Legacy migration. A typed Standard/Flow mismatch is rejected following the observed native restriction. This evidence does not itself establish Studio acceptance. Original sample changes remain unsaved in the disposable workspace; fresh inventory is required before continuing.

Allocation completion after native resume (lead, 2026-09-05)

Resumed the existing CP1 chooser with fresh inventory/foreground capture. The native helper's UIA index selected Provide Electrical Power / FOP1 (verified from the highlighted path) rather than the initially intended navigation output; this is a valid Aircraft-owned output and is the actual benchmark subject. Moved the overhanging dialog within the main window after a bounded-coordinate failure, transferred that output into the selected list, confirmed OK, inspected Allocated Ports: FOP1, and committed Finish. Flow/Out remained selected and both Provided/Required Interfaces stayed undefined. This successfully exercises explicit component-port allocation without deriving interface roles; no component-exchange allocation or accelerator is implied. Disposable Capella sample remains unsaved. Tool-captured screenshots inspected directly; no screenshot files stored.

2026-09-05 routing trial (native, disposable sample): selected Audio Signal FE, Semantic Browser confirmed Play Sound in Cabin/FOP1 to Listen to Audio Announcement/FIP1. Rectilinear corner drag produced no observed movement. Context menu exposes Remove Bend-points and Format > Line Style > Tree/Oblique/Rectilinear. Switched to Oblique, then dragged the diagonal segment (472,485) to (432,415); fresh capture showed a new explicit bend with unchanged semantic endpoints. Reference sample remains unsaved.