[ FM-WS-02 ] // APPS

Closed-Loop Ops: Action, Writeback, and the Reload That Proves It

We closed the loop FM-ON-02 left open: a real, applied, persistent writeback from a Workshop app. The branch wall from FM-WS-01 blocks our own Work Order action, so the write runs against the main-ontology demo: [Example] Route Alert via the demo action [Example] Update Route Alert Status, wired into the FM-WS-01 module with a Button group and published as v0.4.0. The module's core finding is discoverability: actions are invisible until you know that a button's ON CLICK type select (default Event) hides Action as a separate type, and that filtering the Event submenu for 'action' returns, verbatim, No events found. The Route Alert parameter binds to the table's selected-row variable, Object table 1 Active object. Two real writes executed; the second is fully documented: row Id prefix 27fbc45c96a5ad (Cancellation Rate alert, Low priority, MCO -> EWR, Flight Count 666) went from Status Pending Triage to Resolved, green toast 'Edits successfully applied.', and after a full page reload the value is still Resolved. Four field repairs, including the two verification traps: action forms never prefill current values, and the grid shows the stale value until you reload.

VERIFIED 2026-09-08 // OPERATOR // 60 MIN // FM-WS-02
Foundry build // Workshop as deployed on the enrollment on 2026-09-07 and 2026-09-08.
Environment // Avinyr lab enrollment (Foundry cloud)
[ PREREQUISITES ]
  • FM-WS-01. The module, the object table, the Active object variable, and the published app all come from there. Do it first.
  • FM-ON-02. The action contract, submission criteria, and the dry run doctrine that this module pays off.

Field notes from the Avinyr lab. Everything below was observed live in Workshop on our cloud enrollment: wiring on 2026-09-07 starting about 17:55 local, the writes executed and verified on 2026-09-08 between about 14:20 and 16:50 local. The route alert data is the enrollment's own demo ontology. Every screenshot is ours.

[ READ THIS FIRST: WHAT THIS MODULE IS ]

FM-ON-02 built a real action and proved it correct with a dry run, writing nothing. FM-WS-01 built the app surface and hit the branch wall: Workshop reads main, so our Work Order type and its Reassign technician action are unreachable from any app until the proposal merges. This module pays off both threads with the resources that actually exist: it wires the demo action [Example] Update Route Alert Status into the FM-WS-01 ops board, executes it against a real row, and proves the write persisted across a full page reload. The closed loop, action to writeback to updated view, is the whole reason Foundry exists. It is also where the platform hides its best traps.

One honesty note up front, because verification standards are the point of this manual. We executed two writes. The first (row SEA -> LAX, set to Resolved) is corroborated by an after-state screenshot but has no documented before-state of the Status column, so we do not claim it as proven. The second write has a full before/after with a reload in between, and that is the one this module hangs its claims on.

[ WHAT YOU WILL HAVE AT THE END ]

The FM-WS-01 module (ri.workshop.main.module.ff2edd2c-307b-441c-8605-419e39bfb2c7) at v0.4.0, now with a Button group whose button, labeled "Update status", triggers [Example] Update Route Alert Status with its Route Alert parameter bound to the table's selected row. A module-level Capabilities panel that finally reads Actions 1. One documented write: row Id prefix 27fbc45c96a5ad, the Cancellation Rate alert (Low priority) for MCO -> EWR, Flight Count 666, Percent Change 1.186186186186, Status changed from Pending Triage to Resolved, still Resolved after a full page reload. And a map of the four places this workflow tries to lose you.

What you might expectWhat Foundry actually does
You add an action to the app from the object type's panelThe Actions row has no add affordance at all. Variables and Derived Properties have a circled plus; Actions does not. The entry point is a Button group widget
A button's click configuration lists actionsThe ON CLICK type select defaults to Event and hides Action behind it. Filtering the Event submenu for "action" returns, verbatim: "No events found". Actions are not events
The action form shows the object's current valueIt never does. Reopening the form on a row whose Status is already Resolved shows "Select an option..." Operators overwrite blind
The success toast means the view updated"Edits successfully applied." fires immediately while the table still shows the pre-write value. The write is only provable after a reload
You can verify the write with a quick API call from the pagefetch('/api/v2/ontologies') from page context hung indefinitely, and guessed routes 404. Do not guess Foundry routes

[ STEP 1: WHERE ACTIONS HIDE ]

Open the module editor and drill into [Example] Route Alert in the left Overview panel. It reads Variables 2, Widgets 1, Actions 0, with the empty-state sentence, verbatim: "You are currently not using any actions on this object type". Fair enough. Now try to add one from here. You cannot. The Variables and Derived Properties rows carry a circled-plus affordance. The Actions row has nothing. Dead end by design.

FM-WS-02 // 01-actions-zero-state-button-config-crop // Closed-Loop Ops: Action, Writeback, and the Reload That Proves It
[ FIG :: 01-actions-zero-state-button-config-crop ]

The module-level Capabilities panel is no more helpful as an entry point. Its Actions empty state explains the actual mechanics, verbatim: "Actions allow users to edit objects data within a Workshop application. Add a Button Group or Inline Action Form widget to configure writeback Actions." Read that sentence as the module's answer: actions enter a Workshop app through a widget, not through the ontology panel. The panel only lists actions once a widget uses them.

We already had a Button group on the canvas from the FM-WS-01 session's experiments. Select its Button 1 and find the ON CLICK section. It has a type select showing "Event". That select is the door, and it does not look like one. Open it and the options are, verbatim: Action | Event | Export | Scenario event | Function backed export | Export media | Command. Action is first on the list and invisible until the select is open.

FM-WS-02 // 02-onclick-type-action-select-action-crop // Closed-Loop Ops: Action, Writeback, and the Reload That Proves It
[ FIG :: 02-onclick-type-action-select-action-crop ]

One trap deserves its own paragraph because it will cost you time. If you do not know actions are a separate ON CLICK type, the natural move is to open the Event submenu and filter it for "action". The filter answers, verbatim: "No events found". That response is technically true and practically misleading: there are no action events because actions are not events. The platform's own search tells you the thing you want does not exist, one menu away from where it exists.

[ STEP 2: PICK THE ACTION ]

Switch the ON CLICK type to Action and a second select appears: "Select an action...". Its picker lists exactly three demo action types on [Example] Route Alert: "[Example] Assign Alert", "[Example] Close Alert", "[Example] Update Route Alert Status", plus a "Create action type" footer link for making your own. This is the same demo cargo the FM-WS-01 object set picker showed; on main, these actions are what exist.

FM-WS-02 // 03-action-picker-three-demo-actions-crop // Closed-Loop Ops: Action, Writeback, and the Reload That Proves It
[ FIG :: 03-action-picker-three-demo-actions-crop ]

We picked "[Example] Update Route Alert Status". The config panel that appears is worth reading top to bottom once: Default layout (Form | Table, Form the default), an End-user features SWITCH LAYOUT toggle, PARAMETER DEFAULTS ("Local default values for parameters"), and ADDITIONAL OPTIONS carrying three switches with self-explanatory caps-lock names: HIDE FORM AND APPLY IMMEDIATELY IF VALID, CUSTOM ACTION TITLE, BUTTON STATE IF INVALID. We left every default alone. Defaults first; cleverness after the loop is proven.

FM-WS-02 // 04-action-config-parameter-defaults-crop // Closed-Loop Ops: Action, Writeback, and the Reload That Proves It
[ FIG :: 04-action-config-parameter-defaults-crop ]

[ STEP 3: BIND THE PARAMETER TO THE ACTIVE OBJECT ]

Open "Select parameter to configure". The header reads, verbatim: "NO DEFAULT VALUES SET (2)", and the two parameters are "Route Alert" (object type, required asterisk) and "Status" (string, required). This is the action's contract, straight from the ontology: which object, and what status.

FM-WS-02 // 05-parameters-route-alert-status-crop // Closed-Loop Ops: Action, Writeback, and the Reload That Proves It
[ FIG :: 05-parameters-route-alert-status-crop ]

The binding that makes the whole app work: Route Alert, LOCAL DEFAULT VALUE, set to the variable "Object table 1 Active object". That variable is the object table's selected-row output from FM-WS-01. The variable picker opens as a leftward popup with a "Search variables..." box, listing "[Example] Route Alert" (the object set) and "Object table 1 Active object" (the row). Bind the row, not the set. The semantic is now: whatever row the operator has selected in the table is the object this action will edit.

FM-WS-02 // 06-parameter-bound-active-object-crop // Closed-Loop Ops: Action, Writeback, and the Reload That Proves It
[ FIG :: 06-parameter-bound-active-object-crop ]

The moment the binding landed, the module's Overview panel updated in two places: Ontology types went to 2 with a new entry "[Example][Log] Update Route..." (badge 0), and Capabilities > Actions went to 1, listing "[Example] Update Route Alert Status - Used in: Button group 1". The [Log] type is a companion object type the demo action apparently writes alongside the status change. Noted, not yet investigated.

FM-WS-02 // 11-overview-actions-1-log-type-crop // Closed-Loop Ops: Action, Writeback, and the Reload That Proves It
[ FIG :: 11-overview-actions-1-log-type-crop ]

Last cosmetic step: rename the button text from "Button" to "Update status". Then Save and publish. No dialog, no spinner worth mentioning, published instantly. The header shows v0.4.0 with the verified check.

FM-WS-02 // 07-published-v040-crop // Closed-Loop Ops: Action, Writeback, and the Reload That Proves It
[ FIG :: 07-published-v040-crop ]

[ STEP 4: EXECUTE THE WRITE ]

Open the published view (/workspace/module/view/latest/ri.workshop.main.module.ff2edd2c-307b-441c-8605-419e39bfb2c7). Click row 1, the SEA -> LAX alert, and click "Update status". The action form modal opens titled "[Example] Update Route Alert Status" with Route Alert prefilled, verbatim: "Long Arrival Delays alert (Low priority) for SEA -> LAX". The Status field is a dropdown reading "Select an option...".

FM-WS-02 // 08-action-form-prefilled-sea-lax-crop // Closed-Loop Ops: Action, Writeback, and the Reload That Proves It
[ FIG :: 08-action-form-prefilled-sea-lax-crop ]

The Status options are, verbatim: Pending Triage | Resolved | Auto-Closed.

FM-WS-02 // 09-status-options-pending-resolved-autoclosed-crop // Closed-Loop Ops: Action, Writeback, and the Reload That Proves It
[ FIG :: 09-status-options-pending-resolved-autoclosed-crop ]

We chose Resolved and clicked Submit. The toast said "Applying edits...".

FM-WS-02 // 10-applying-edits-toast-crop // Closed-Loop Ops: Action, Writeback, and the Reload That Proves It
[ FIG :: 10-applying-edits-toast-crop ]

Now the first verification trap. Reopen the form on the same row. The Status field shows "Select an option..." again. The form does not prefill the current value, ever. Inside the form, the operator cannot see what the object currently says; the current value has to be visible somewhere else (in our app, the table) or the operator overwrites blind. Design your boards accordingly.

The second verification trap is the table itself. The object table already carries all 23 properties as columns, including Status, but the grid is horizontally scrollable and Status sits off-screen to the right. Verifying a write inside the module means scrolling, not changing the schema. A wheel-scroll revealed the Status column: demo rows already carry a mix of Resolved and Pending Triage pills, and row 1 showed Resolved. Consistent with our first write, but we had no before-shot of that column, so consistent is all it is. We treated this as the before-state for a second, fully documented write.

FM-WS-02 // 12-status-column-before-second-write-crop // Closed-Loop Ops: Action, Writeback, and the Reload That Proves It
[ FIG :: 12-status-column-before-second-write-crop ]

[ STEP 5: THE DOCUMENTED WRITE AND THE RELOAD ]

Row 7: Id prefix 27fbc45c96a5ad, the Cancellation Rate alert (Low priority) for MCO -> EWR, Flight Count 666, Percent Change 1.186186186186, Status "Pending Triage". Select the row, click "Update status". The form prefills, verbatim: "Cancellation Rate alert (Low priority) for MCO -> EWR".

FM-WS-02 // 13-form-prefilled-mco-ewr-crop // Closed-Loop Ops: Action, Writeback, and the Reload That Proves It
[ FIG :: 13-form-prefilled-mco-ewr-crop ]

One misfire, reported because it will happen to you: our first attempt to pick Resolved clicked a Resolved pill in the table behind the modal backdrop, which dismissed the dialog. Reopened, clicked the Status dropdown precisely, chose Resolved from the actual listbox, clicked Submit. Green toast, verbatim: "Edits successfully applied."

FM-WS-02 // 14-edits-successfully-applied-toast-crop // Closed-Loop Ops: Action, Writeback, and the Reload That Proves It
[ FIG :: 14-edits-successfully-applied-toast-crop ]

And here is the trap that turns confident operators into liars: the table still showed "Pending Triage" immediately after the toast. No auto-refresh fired. If you demo this to a stakeholder at that moment, the app appears broken at the exact moment it succeeded. The write is real; the view is stale.

The proof instrument is the oldest one there is: a full page reload. Reload the published view, scroll to the Status column. Row 27fbc45c96a5ad, Flight Count 666, now shows "Resolved", green pill. Every other row unchanged. The write persisted in the ontology, not in some client cache. Closed loop, proven: select row, fire action, toast, reload, updated view.

FM-WS-02 // 15-after-reload-row666-resolved-persisted-crop // Closed-Loop Ops: Action, Writeback, and the Reload That Proves It
[ FIG :: 15-after-reload-row666-resolved-persisted-crop ]

For completeness, the independent-verification attempts that failed: fetch('/api/v2/ontologies') from page context hung indefinitely (a session-cookie call to /api/v2 that never resolved; cause not determined), and the guessed routes /object-explorer and /workspace/search both return the enrollment's 404 pages. The FM-ST-03 rule stands: do not guess Foundry routes.

[ FIELD REPAIRS ]

FR-1: actions are invisible until you know the trick. Symptoms: the object-type Overview panel shows Actions 0 with no add affordance (Variables and Derived Properties have a circled plus; Actions does not); the module Capabilities panel only lists actions already in use; the Button's ON CLICK type select shows "Event" and hides "Action" behind it; filtering the Event submenu for "action" returns, verbatim, "No events found". Cause: actions enter a Workshop app through a widget's click configuration, not through ontology panels, and they are a distinct ON CLICK type, not an event. Fix, the full path: Button group > button > ON CLICK > type select > Action > Select an action. Evidence: 01-actions-zero-state-button-config.png, 02-onclick-type-action-select-action.png, 03-action-picker-three-demo-actions.png.

FR-2: action forms do not prefill current values. Symptoms: reopening Update Route Alert Status on a row whose Status is already Resolved shows "Select an option..." Cause: by design; the form is a write instrument, not a read view. Fix: none in the form. Make the current value visible outside the form (the table's Status column in our app) so operators never overwrite blind, and train them to look before they submit. Evidence: 08-action-form-prefilled-sea-lax.png, 09-status-options-pending-resolved-autoclosed.png.

FR-3: the property you wrote may already be a table column you cannot see. Symptoms: after a write, the Status value seems absent from the app. Cause: the object table ships all 23 properties as columns and the grid scrolls horizontally; Status was off-screen to the right. Fix: wheel-scroll the grid, or pin/reorder columns so the property your action writes is visible without scrolling. Verification in-module requires the column on screen, not a schema change. Evidence: 12-status-column-before-second-write.png.

FR-4: success toast, stale grid. Symptoms: the green toast "Edits successfully applied." appears immediately while the table still shows the pre-write value; no auto-refresh observed. Cause: the write commits server-side; the published view does not re-query on its own. Fix: verify with a full page reload. Our documented write (row Id prefix 27fbc45c96a5ad, Pending Triage to Resolved) showed Resolved, green pill, after reload, with every other row unchanged. Evidence: 14-edits-successfully-applied-toast.png, 15-after-reload-row666-resolved-persisted.png.

Lab note (tooling, not platform): the editor's Blueprint simple-select controls ignored synthetic and naive scripted clicks during this session (aria-expanded flipped true but no listbox rendered); element.focus() followed by a trusted Enter key opened them. If you automate Foundry's editor, budget time for its select widgets. This drove most of the wiring time and is not a platform defect an operator will hit with a mouse.

[ FAQ ]

Did the write actually persist, or just look applied?

Persisted. The toast "Edits successfully applied." is not the evidence; the reload is. After a full page reload of the published view, row 27fbc45c96a5ad (Flight Count 666, MCO -> EWR) shows Resolved, and all other rows are unchanged. A client-side illusion does not survive a reload.

Why is only one of the two writes claimed as proven?

Because only one has a documented before/after. The first write (SEA -> LAX to Resolved) executed and the after-state is consistent with it, but we had no before-shot of the Status column for that row, so the honest claim is corroborated, not proven. The second write has Status Pending Triage on camera before, Resolved after a reload. That is the claim.

Why the demo action instead of our Reassign technician action?

The branch wall. Our Work Order type and its action live on an unmerged branch, and Workshop reads main (FM-WS-01, FR-2 and FR-3). The demo type [Example] Route Alert and its three demo actions are what main offers. The wiring technique is identical; the day the proposal merges, the same Button group pattern works against our own action.

What is the [Example][Log] Update Route Alert Status type that appeared?

A companion object type the demo action apparently writes in addition to updating the alert. It showed up in Ontology types the moment we bound the action, badge 0. We have not opened it yet; tracking what an action writes beyond its target object is a future module.

What about HIDE FORM AND APPLY IMMEDIATELY IF VALID?

A real switch on the action config, left off. With every parameter defaulted and valid, it would apply the action with no form at all: one click, one write. Powerful and dangerous in exactly the way the name suggests. Untested here.

[ NOT TESTED ]

  • The Inline Action Form widget (the Capabilities empty state names it as the second writeback entry point)
  • ENABLE INLINE EDITING on the object table (cell-level writeback without a form; spotted in column configuration, unexercised)
  • HIDE FORM AND APPLY IMMEDIATELY IF VALID, CUSTOM ACTION TITLE, BUTTON STATE IF INVALID, and the SWITCH LAYOUT end-user toggle (all left at defaults)
  • Table layout mode for the action form (Form only)
  • The other two demo actions, [Example] Assign Alert and [Example] Close Alert
  • Create action type from the picker footer (authoring from Workshop instead of Ontology Manager)
  • What the companion [Example][Log] Update Route Alert Status type contains after our writes
  • Whether any table auto-refresh option exists that would remove the reload step from FR-4
  • Action execution against our branch Work Order type (blocked on the merge, as before)

[ NET POSITION ]

The loop is closed, on camera. The FM-WS-01 board is now a writeback surface at v0.4.0: one button, "Update status", wired to [Example] Update Route Alert Status, its Route Alert parameter bound to the table's active object. One write is proven end to end, Pending Triage to Resolved on row 27fbc45c96a5ad, green toast "Edits successfully applied.", value still Resolved after a full page reload; a second write is corroborated and labeled as such. The doctrine from FM-ON-02 holds: the dry run proves the action, the app applies it, and verification means a reload, not a toast. The two traps worth memorizing are discoverability (actions hide behind the ON CLICK type select, and they are not events) and stale views (the grid lies to you until you reload). Next in the track: inline editing, the [Log] companion type, and, once the proposal merges, rerunning this exact playbook against our own Work Order data.