Optional technical reference. This material is for developers, integration specialists and platform administrators. For the consultant lesson, read the practical guide.
Preserved from source baseline
d4587c7c0e073e58c2d430342f65ac55dd701bf4; source/static examples retain their stated scope. They are not new runtime verification or required consultant setup steps.
Current Live guidance — 8 November 2026
Source-qualified from upstream 498b332b08 and its process retirement and Live updates; this is documentation source review, not a new runtime proof. The pinned historical body below is unchanged and may name removed screens.
- Live opens lifecycle cases only. A process without a lifecycle has no Live tab. An old direct Live link explains this and points to Monitor, where those runs can be followed. The removed definition-wide runtime screen and its retry, cancel, suspend, position-repair and migration controls are not an alternate route; Monitor does not change those runs. Lifecycle cases retain their authorized actions in Live.
- Restart and undo: Live's Restart from… replaced its former Move to another step. The old runtime screen's position repair was removed. An undo can be refused when the case moved on, ended or failed, its position changed, or its incidents changed; do not follow the historical Operate example as a current instruction.
- One stage's flow: the current consultant guide explains Other actions → Move this flow to another version… and Undo the last flow move…. Only versions used by one of the 30 newest published lifecycle versions for the same stage/flow are offered; case-specific designs are excluded. Read the actual dry run before confirming. The move affects only that stage's flow and has its own qualified undo; it does not replace the whole-case version-move actions.
- Access to an opened case: when Live cannot establish current access, case content and repair/detail controls retire. Denial uses the neutral Not available state. An access-check outage can offer Retry to read that case again; that does not repeat a repair, migration or workflow action.
Live view of a lifecycle
A working route through this reference
Live answers what is happening in actual cases of a published lifecycle? Design answers what the next release should do; Debug tests a captured model. Keep those modes separate. The detailed reference below is intentionally extensive, including qualified candidate/history material. Start with one of these routes rather than reading every matrix before opening a case:
- Read one case: open its admitted link, read the current case/model/version line, select the waiting state and inspect the actual child/task.
- Work an assigned task: follow its permitted action, use the pinned form, then read the canonical completion receipt.
- Inspect a group: choose model/version/all-version scope and filters, then read only the counts/rows currently offered to that reader.
- Intervene: open the specific native preview, review its expectations/refusals, explicitly confirm with a reason, and inspect the actual result/history.
For the synthetic leave story, Sara may see her Review task but still lack reassignment, migration or restart authority. Nadia may inspect more of the design without becoming a task participant. A visible group count is not permission to act on all cases behind it.
| Decision | Read before acting | Expected follow-up |
|---|---|---|
| Is the case waiting or failing? | Actual snapshot, waiting tasks and current failure/history | Follow the real execution coordinates |
| Can I complete this task? | Current participant/action and captured form rights | Canonical task completion receipt |
| Can I reassign these tasks? | Group preview, eligible person and reviewed task IDs | Confirmed batch result; changed groups require new preview |
| Can I restart or skip? | Native case-restart dry run, expected fences and refusal | Result/journal, not “HTTP 200 means restarted” |
| Did the external action happen? | Actual external outcome evidence | Reconcile UNKNOWN before consequential repeat |
A reason/confirmation dialog does not grant permission. Denied deep links remain neutral unavailable; access outages stay distinct from denial. Runtime/UI acceptance of dated candidate sections is not newly established by these source-reviewed recipes.
Worked examples
Example FLOW-LV-01 — Follow a case to its actual waiting child
Scenario and inputs. Sara opens leave-2026-014 from an admitted report row. The link supplies the actual parent execution ID; the business reference alone is not the engine ID. Release 2 may exist while this case remains pinned to release 1. Sara can inspect the case but should not request unrelated child instances merely because their names look similar.
Procedure. Read the selected case’s definition identity, lifecycle context and snapshot using the /api/process-operate/instances/{id} reads. Match the current parent/state to the actual stateFlows child reference and resolve that child with its own model/version. Select the waiting task on that execution. Inspect current failure and retained history separately: an earlier recorded failure can remain after recovery. Keep the current workspace and authorized selection visible while navigating.
Expected result. The diagram, task and detailed trace refer to the same actual case and immutable models. The current publication does not silently replace the model used to interpret an older execution.
Failure and recovery. If immutable model evidence is missing, show the supported unavailable context rather than latest/draft. If current access cannot be established, hide retained protected content while retrying the admitted read. An old visible diagram is not a current authority witness.
Sources. ProcessOperateController.java:513; ProcessOperateController.java:525; ProcessOperateController.java:533.
Example FLOW-LV-02 — Complete Review from Live and understand the next step
Scenario and inputs. Sara is an eligible reviewer of Mohammad’s actual waiting task and can view its captured published form. Nadia’s broader designer access is irrelevant to Sara’s task permission. The shared case has a real task ID returned by the server; do not pass the business reference or state ID to the completion endpoint.
Procedure. Open the permitted task action from Live. Claim only if the authored candidate queue offers it, then inspect the pinned form and any saved draft. Fill the allowed review fields and submit the actual authored action. Read /api/tasks/{taskId}/completion-receipt after the response or a lost transport reply. Interpret the returned progression and display labels: WAITING_FOR_OTHERS, RECORDED or SENT_FORWARD mean different things, and the case can be complete only when the recorded progression says so.
Expected result. The task records Sara’s allowed response and Live can refresh its actual position. The public receipt explains what is known without exposing internal case/task identifiers or naming unrelated work as the next responsibility.
Failure and recovery. If completion is uncertain, read the receipt/current state before another action. Do not mint an arbitrary submit action, send protected form fields because they were visible, or infer success from a button becoming unavailable.
Sources. ProcessOperateController.java:568; TaskController.java:145; TaskController.java:208; TaskCompletionReceiptResponse.java:10.
Example FLOW-LV-03 — Preview and confirm a group reassignment
Scenario and inputs. An authorized operator needs to hand open Review tasks to Sara while another reviewer is absent. The selected group is bound to a lifecycle key, version/scope and current filters. Sara’s actual approved account ID must come from the person picker; a display name supplied in a body is not trusted. This is a complete preview body, with deployment-specific IDs substituted by the reader.
{
"assignee": {
"id": "actual-sara-user-id",
"type": "USER"
},
"skipped": []
}
Procedure. POST the body to /api/process-live/definitions/{definitionKey}/group/reassign/preview?version={version}&scope=version with the current group filters. Inspect the proposed tasks, allowed target and any refusals. For confirm, use the native returned/reviewed expected task IDs, typed phrase, reason and skipped list; retain the same selection and actual person ID. Read the batch result before continuing to another batch.
Expected result. The server rechecks current task permissions/assignment policy and compares the reviewed task set. The preview itself changes nothing and never acts as a general grant.
Failure and recovery. If the group changed, obtain a fresh preview rather than inventing task IDs or ignoring a 409. A group/role destination is refused here; use an actual eligible person. Do not broaden enumeration to hidden cases in order to make a batch count match.
Sources. ProcessLiveGroupReassignController.java:28; liveApi.ts:363.
Example FLOW-LV-04 — Use a restart preview without assuming every200 changed the case
Scenario and inputs. An operator investigates a stuck leave case and has the required intervention rights. The exact current task/service effect might still be uncertain. The operator selects an actual published step ID from that case’s model. The following is a complete dry-run request for the restart controller, not a confirmed mutation.
{
"action": "RETRY_STEP",
"targetId": "actual-step-id",
"expected": null,
"reason": null
}
Procedure. POST to /api/process-instances/{caseId}/case-restart/preview. Read the offered/refused action and all current expectations. Before a confirm, reconcile any unknown external effect, then copy the actual returned expected fences and add the meaningful reason required by the supported operation. Submit through the native confirm path and inspect its result and operation history. If Undo is offered later, use its separate current preview and journal identity.
Expected result. A confirmed operation reports its actual outcome, including NOT_RESTARTED where applicable; an HTTP 200 is not a promise that restart occurred. The selected action determines whether a step runs again, is skipped, or a state is restarted.
Failure and recovery. On a 409 obtain a new preview; on a business refusal address the actual cause. Never fabricate fences, delete the old incident, or repeat a potentially accepted provider effect merely to make the diagram advance.
Sources. ProcessCaseRestartController.java:29; ProcessOperateController.java:551.
Detailed reference
The current live-view reader is LifecycleLiveViewService in
platform-execution-core; it separates ordinary reader scope from aggregate and
intervention authority. An open case or visible aggregate does not grant every
intervention. Detailed action support remains subject to its current native
controller/service. Dated candidate reports below are retained evidence, not
current-head runtime certification.
Spec 089 (SCRUM-3057). This guide covers all of Live:
- the live state diagram, the details panel and opening a state (SCRUM-3058);
- choosing KPIs and the report (SCRUM-3059);
- a group of cases (SCRUM-3060);
- one case (SCRUM-3061);
- changing the design while cases run (SCRUM-3062);
- applying an edit to one case only (SCRUM-3063, behind a workspace setting).
The Monitor tab next to Live is described in The Monitor (spec 108, SCRUM-3214).
Opening it
Open a published lifecycle in the process designer and choose Live, or choose View live on its row in Build → Lifecycles or at the top of its lifecycle page (spec 095 FR-044): it opens Live on the latest published version. View live is disabled, with the reason ("Not published yet"), for a lifecycle never published; Open designer beside it opens the draft in the designer. The designer's first mode is Design (it was "Lifecycle"); Verify, Live, Monitor and Debug keep their names. Before a first publish, the text beside the modes says why Live and Monitor are not available yet ("Live and Monitor: available after publishing").
One line under the lifecycle's name says where you are (spec 095 FR-046): the mode, the version, and which cases the figures cover — "Live cases · Published v3 · All 12 running cases · 2 more still running on other versions", or with a group "5 of 12 cases", or with a case open "This case". In the designer the same line says what you edit, what it is based on and whether it is saved — "Editing draft v4 · Based on published v3 · All changes saved", or while editing for running cases "Editing for INC-2522 · Case currently uses v3" (then it leads the banner over the diagram).
The state diagram fills the The state diagram fills the window and a details panel sits on the right. On a window narrower than 1600px the panel is a drawer over the diagram instead, so the diagram has the full width and its names stay readable: it opens when you select a state, step or case, closes with × or Escape (the selection stays), and Details in the toolbar opens it again (SCRUM-3176). While it is open the diagram fits beside it, so every state stays in view; closed, the diagram takes the full width again. The panel has a fixed width: at least 380px (on a 1366px screen), widening with the screen up to 480px, and up to 520px for a case. It shows what you selected; what the diagram shows is set behind Customize view (see Choosing the KPIs).
On entry the diagram is fitted to the canvas. On a large screen the fit may magnify it (up to twice its drawn size, but never so far that a state name grows past 18px), so a small lifecycle fills the space. A zoom or pan you make yourself is kept when the figures refresh; Fit (the corner control) fits it again, and opening another state, case or version starts fitted. Cases and Migrate in the Live toolbar stay in Live: Cases opens Live's own case table and Migrate Live's own move dialog (see Live's case table and Moving running cases below). Nothing in Live leads to the older runtime screen; an old link to its Cases or Migrate tab opens Live.
You need the PROCESS_INSTANCE_VIEW right, globally and on the lifecycle. Every figure covers your
current workspace only.
Direct case failure page (SCRUM-4040 candidate)
A direct link at /workspaces/{workspaceKey}/cases/{executionId}/live opens the
recorded failure for one independently permitted case. Workspace resolution uses
the signed-in person's own workspace list. Being on that list does not grant
case access; the page checks the exact case separately before reading failures.
Refresh checks the workspace again before the case. If that check is pending,
the previous case details and copy controls disappear. A confirmed unavailable
workspace shows the neutral unavailable state; an unchecked connection offers
Retry without exposing the previous case.
This candidate's case-page checks and App route bootstrap change are implemented. Full runtime-only browser acceptance remains pending; this is not a released runtime-only access claim.
Reading an execution failure (SCRUM-4040 candidate)
This section describes the implemented candidate presentation. Runtime, privacy, video and observed user acceptance are still pending; it is not a release claim. The direct case page above checks case access independently of Designer access.
Read the failure card's explanation and next check first. The permitted location, run/parent state, saved-change outcome and external-action outcome are separate facts. A parent can still be running while a nested step has failed. If the card says an outcome is not confirmed, do not infer that changes were rolled back or that an external action is safe to repeat. The explanation adds no retry right.
The heading distinguishes Current failure, Resolved incident, Earlier failure and Recorded failure. A retained earlier card does not mean the run has failed again. If a stale-information warning appears, the latest update could not be loaded; use the page's existing refresh or recovery control and check the resulting state before deciding what happened.
- Safe details expands the code and permitted evidence. The plain-language explanation and next check are already visible without expanding it.
- Copy safe evidence, when offered, copies the displayed explanation, location, impact, support reference, code and safe details, including any stale warning. Share it through your authorized support channel; do not add passwords, tokens, raw request bodies or protected business values.
- Show failed step appears only when a permitted recorded location can be opened. It opens that recorded execution/model context. An absent action does not authorize opening the current draft or requesting a hidden child.
- A clipped long explanation offers a full-description action. Keyboard users can focus these controls with Tab and activate them with Enter; Escape closes the full-description or recorded-location dialog.
When a nested cause is protected, the card can say that the step could not finish and detailed cause information is unavailable, then direct you to the workflow owner or support with the parent support reference. The child name, details and navigation remain unavailable. Failure location is unavailable is a truthful fallback, not evidence that no failure occurred. The parent reference must not be substituted with a guessed child reference.
Older failures may explicitly say their support reference is unavailable. Report that fallback together with the permitted case context to the owner; do not invent a cause or reference. An unavailable deep link does not disclose why access was refused. Ask the authorized owner to investigate rather than requesting hidden child or model endpoints.
Reading the diagram
-
A state card shows its name,
N here(open cases in the state now),N need attention(of those, cases with an open incident on the case or its state flow, or whose state flow failed), and its kind (Initial, Terminal, Sub-process).N hereandN need attentionare buttons: each opens Live's case table on that state's cases now (and, forN need attention, only those needing attention), keeping your other filters. While a filter is on another state they are disabled with the reason. Inside an opened state the counts are runs of its flow: a state that runs its flow once per item counts each run. It also shows three figures:- visits: how often cases entered the state (a case that comes back counts again, so visits are not cases);
- median visit: half of the completed visits took less than this;
- 90th pct visit: nine in ten completed visits took less than this.
Each figure says in full what it measures when you point at it, and to a screen reader ("Completed visits: median duration").
The bar under the figures is the state's share of all the time spent in the lifecycle. It counts finished visits and also the time cases still in a state have waited so far, so a state where cases are stuck shows it (SCRUM-3193). Paused cases count too, and one case waiting a long time can hold most of the share. The visit durations (median, 90th) stay finished visits only. A terminal state shows how many cases ended there instead.
A case that has ended left its last state when it ended (SCRUM-3334), the same rule as its case lens uses. If it completed there (its terminal state), that visit is finished and timed up to the end. If it was cancelled or failed there, the time it spent counts toward the share of time, as a step's time up to a cancellation does. It is not a finished visit, so the median and 90th percentile still describe visits that were completed. A terminal state's median and 90th percentile (in the state's details) are how long cases took to end after reaching it, which is the time its final flow ran. A case that moved on to a state this version does not draw (another version's, or its own design's) left the state it was in at that moment; its time there is a finished visit, whether the case still runs or has ended. Such a move is not a route, so a state's completed visits can be more than the exits counted under "Where cases went next".
Inside an opened state, steps are counted and timed exactly as the Process Monitor counts them. A step retried after a failure stays one visit, timed from its first entry. A visit counts as finished when the step was completed or the case moved on to the next step. The time a step spent until a failure, a cancellation or the end of the case counts toward the share, but not toward the median or 90th percentile. When one branch of a case fails and is retried, a parallel branch that was waiting at that moment keeps its visit: it goes on adding time until it is completed, moves on, is cancelled, or the case ends, and is then timed as usual. The figures are worked out when you open the view, so this shows from the retry on.
-
A route is labelled with its business condition and how many cases took it, with that number's share of all exits from the state (a case that left twice counts twice). A route nobody took is drawn faint and labelled
none. When two routes join the same two states, the engine cannot tell them apart, so they share one figure and say "with another route". -
This version / All versions sets which cases every figure covers. On This version, the line under the title also says how many cases are still running on other versions. A version with no case of its own says so ("No cases on version 2. 2 cases are running on other versions.") and offers View all versions; only a lifecycle with no case on any version says that no case has started yet.
Colours (spec 106) mean the same on the diagram, the details panel and a case:
- indigo is running: the Running and Here now tiles and "N here". The bars are indigo, deep indigo above the warning share. Buttons, selection and focus keep Studio's blue;
- amber is needs attention, and only that: the Need attention tile, the "N need attention" badge, a state's outline and the health mark;
- teal is completed;
- lilac marks a state that runs its own flow ("Sub-process");
- neutral slate is used for labels such as Initial and Terminal.
A selected state has a blue ring around its card. The ring is separate from the state's outline, so a selected state that needs attention keeps its amber outline (spec 095 FR-063). Text in Live reads at least 13px (labels 14px), the toolbar's buttons are 36px tall, and every control is at least 24 × 24px. A long route condition wraps to two lines instead of being cut short.
Errors (something could not be read or done, a failed step inside a flow) stay red. The report keeps its own two lists apart: rework is amber there and needs attention is red. The dark theme keeps its dark surfaces with the same meanings. The colours apply to Live only, and look the same whichever light theme is chosen.
Percentiles are nearest-rank: each one is a duration some case actually took. On a lifecycle with more than 2,000 cases, visits, routes and times describe the 2,000 most recent cases, and the panel says so. Counts of open work always cover every case.
One case
Open a case with Open a case in the Live toolbar (two characters at least; the twenty most recent matches; it jumps to the case and never changes the figures), or choose one under "Cases here" in a state's panel. From the keyboard, the first match is highlighted: Enter opens it, Down and Up move the highlight to another match, and Escape closes the list (SCRUM-3681). Enter opens nothing while there is no match, or before the matches for what you typed have come back. Filter by reference or title in the filter bar is the other search: it narrows the cases in view and every figure (spec 095 FR-049). The diagram then tells that case's story on the version it runs:
- states it passed show how long it spent there; the state it is in is outlined and marked Current state ("Here now · in this state for 2h", or "Stuck here" with the Needs attention mark when a step failed); a state it never visited keeps its name readable on a quieter, dashed card and says "Not visited by this case";
- the routes it took are drawn bold, the others as the lifecycle's plain routes;
- open a state to see its steps: "took 3m", "waiting 12m", or failed; and the flows it took.
The panel shows the case's reference, title, status, version and who started it when. When its version has a case service level (spec 124), a Service level line follows: the target (in working time with the calendar's name, or "around the clock"), when it is due, and where the case stands (On track, At risk, Breached, Met, Missed, Ended) with the time left or over. Ended is a case that was cancelled or failed: it neither met nor missed its target, so no time is shown. Without a service level there is no line. Its status is two signals, the same in the case panel, the case bar under it, the search results and the group's cases: what it is doing (Running, Paused, Completed, Failed, Cancelled) and, when it needs someone, Needs attention (an icon and a label). A running case with a failed step is "Running" and "Needs attention", never a red "running".
Below the name, the panel says, in this order, What happened (for example "A step failed.", "An incident is open, though no step failed." or "It is running; nothing needs attention."), Where (the state, and the step it stopped at), and, when the case needs attention, the Reason and what to do Next:
- the reason comes from the failed step's own incident. The message the engine records is technical, so it is shown only to someone who may see technical values (as on the Work tab). Everyone else sees the business wording where the platform has one for that kind of failure, and otherwise "Not known to you". When the step recorded nothing, the reason reads "Not known". Someone who may not see incidents, or whose failed step is in a run they may not open, is told so: it never reads as "no problem";
- Inspect failed step comes first: it opens the step in its state's flow, with the case kept in view, and the Timeline lists that state's steps. When the case failed outside a step, it opens Work, where its incidents are. Move to version N and retry step (see "Fix a failed case" below) and Retry the failed step stand beside it. When a newer version is published and the move can be made, the move-and-retry comes first instead;
- Review missing outcome comes first only when the platform names a configuration cause for the failure (a later release supplies it); it opens the design for this case, and Retry is then disabled: the step would fail again until the design is fixed;
- when the state's flow ended at an end event the state does not declare as an outcome (the Design view says "Publish will refuse undeclared exits" for it), the case reads, for example, "Containing ended at 'Ramp closed', an outcome it does not declare." with the reason "The design has no route for this outcome." Declare the outcome in Designer comes first and opens the design for this case at that end event, with the guidance "Declare 'Ramp closed' as an outcome (or change the end), publish, then move this case and retry." Retry the failed step is disabled: "Retrying ends the same way until the design declares this outcome." Move to version N and retry stays disabled while version N still does not declare the end ("Version N still does not declare 'Ramp closed' as an outcome of Containing; declare it and publish first."); once a version that declares it is published, it comes first;
- when the case needs attention because of an open incident and no step failed, the open incidents of the case and of its current state's run are listed here instead, each with where it is, what happened and what to do next. When one of the two cannot be read (no right to see it, or a run you may not open), the other is still listed and a line says which part was not read; the panel says no incident is open only when both were read. An incident on the case itself, with no wording of its own, reads "This case needs attention before it can continue." There is nothing to retry. The Work tab keeps the full list, resolved incidents included.
- someone with the right to resolve incidents can choose Resolve on one of those listed problems when it no longer applies (SCRUM-4175). It asks "Why does it no longer apply?" and cannot be confirmed without an answer; the reason is recorded with their name, shown in the case history as Resolved a problem, and, for a problem on the case itself, listed with the problem under Monitor's recently closed problems. A problem resolved on one of the case's state-flow runs shows in the case history only to people who may also view that run, and is not listed in Monitor. It closes that problem only and does not change the case. It is not offered to people without the right, and it is refused for a problem that is already closed and for the recovery point of a failed case (retry or cancel the case instead).
- a decision that cannot choose a path (no condition matches and there is no default, or a condition cannot be evaluated), including a state's exit rule, is a failed step at that decision (SCRUM-4172): "A step failed — at Delay over 60 min?" (an exit rule reads "Exit of State"), with the reason "No path matched at '…' for this case's values, and it has no default path." The work that led there stays recorded, and the person who completed it was told the case stopped there. Recover it like any failed step: Change data (Repair value) also corrects the value in the failed state's run, listed under "Active sub-cases", then Retry the failed step. Retrying without a fix keeps one incident; it does not add more.
- an incident closes by itself, with a reason, when the case moves on from the position it describes or the case ends (SCRUM-4172), so a recovered or finished case is not counted as needing attention. Closed incidents stay listed under Work and under Monitor's "Recently closed problems".
Edit the design while it runs… stays next to the case bar (Pause / Resume, with a reason). The other actions are under Other actions, in three groups (spec 116 S16):
- Work in this case: Work on the open task… and Reassign task… (both open the case's task in a dialog over Live; see "Working on a task from Live"), and Change data… (the Data tab; a value can be corrected while the case is paused or after a step failed).
- Recover a failed case: Retry the failed step, Move to version N and retry, Put back after Fix and retry… (a failed flow only) and Restart from… (opens the case's context menu on the failed step; see "Restart from here"). When nothing has failed in the case, the group is one disabled entry, "Recover a failed case — Nothing has failed in this case", instead of a list of disabled items. When an incident is open but no step failed, the items are listed, each disabled with its own reason. A failed case's Retry the failed step and Move to version N and retry are also the panel's Next buttons; both run the same action.
- End or move the case: Cancel case… (with a reason) and, for a case on its case-specific design, the move onto a published version.
The arrows, Home, End and type-ahead go through every group in order, disabled items included, so each reason can be read. Cancel case says what it affects, this case only, in the menu and again before you confirm. Restart from… replaces Live's former Move to another step; Operate keeps its position repair. Every action is an existing one, under its own permission and recorded with your name. An action you may not take is not shown at all (owner decision DEC-16, SCRUM-3538): without the right to assign tasks there is no Reassign task…, without the right to correct case data no Change data…, without the rights of Retry no Retry the failed step or move-and-retry, and so on; a group left with nothing in it is not shown either. An action you may take but that does not apply to the case right now is listed, disabled, with the reason. Hiding is only what you see: the server still checks your rights on every request. An ended case offers none. The tabs are Timeline (the road, with the steps of the opened state), Data, Work and Activity. This panel is the case view: there is no separate "full case view" from Live. Open case on a lifecycle state's case list also opens the case here. Back to all cases returns to where you were (the case table, when you opened the case from it).
| Parameter | Meaning |
|---|---|
liveCase=<id> |
the case shown |
liveTask=<id> |
the task dialog is open on this task of the case |
liveTaskAction=hand-on|delegate |
the task dialog opened on the Hand on (Reassign) or Delegate picker; you still pick and confirm |
liveGroupReassign=<step> |
with no case open: the group reassignment of the open tasks at that step of the opened state's flow |
Working on a task from Live
A task of the case is worked in a dialog over Live, never on the workspace task page (spec 116 S14). Under Other actions:
- Work on the open task… opens the case's open task: the run of its current state first, then the case itself. A run you may not open is never searched. When the case has no open task (its current step is not a person's task, for example a failed case stopped at an automatic step or an end), Work on the open task… and Reassign task… are disabled with "This case has no open task." (spec 116a, SCRUM-3682). The task is found among those you may open at the case's current step, including one waiting in the pool or held by someone else (spec 116a, SCRUM-3679). If no task turns out to be open when you choose it, it says "No one is working on this case right now, so there is no task to work on."; if the step's tasks are ones you may not see, or the case is in a run you may not open, it says "This is not available to you".
- Reassign task… opens the same dialog directly on Hand on: pick the person, give a reason if you like, and confirm. The dialog closes and Live reads the case again. It needs the right to assign tasks; without it, it is not shown (DEC-16). Where the process forbids handing the step's task on, Hand on and Delegate in the dialog are disabled with "The process forbids reassignment for this step." before you pick anyone.
The dialog is headed by the step and the case ("Secure the scene · INC-2519"). It is the same task surface as everywhere else: the task's form, Claim task, completing, Hand on, Delegate, Re-deadline, Return to <person> for work delegated to you (a reason is required), comments and attachments. A supervisor may hand on or delegate a task somebody else holds, or one still waiting in its pool, when the server allows it; completing stays the holder's. An older server that does not say what you may do offers no hand-on of someone else's task. After completing, the dialog shows what was recorded and what happens next. It does not offer the evidence and note of a manual task; open those tasks from My work.
Back to Live, the close button or Escape close it. Nothing you type in the dialog is saved as a draft (the task page keeps drafts; the dialog does not). When you have typed something that is not sent (a form value or a comment), every way out asks first: closing, opening another case or task, leaving the case, browser Back or a link, and the close that follows a Reassign. A reload or closing the tab gets the browser's own warning. If you confirm, what you typed is gone. Closing puts you back exactly where you were: the same case, open state, selected step and canvas position, with focus on the control that opened it.
Changing only the picker the dialog opens on (Reassign on the task already open) discards nothing and asks nothing. After Discard, browser Back still goes back (it is not turned into a new page in the history). If the case cannot be read again while the dialog is open, the dialog stays, says "The case could not be read again just now; it is shown as it was last read", and keeps what you typed.
The dialog is in the address (liveTask, liveTaskAction), so a reload or a shared link opens it again over the same
case. Opening it from the address only reads: it never claims, saves, completes or hands anything on; liveTaskAction
only opens the picker, and you still confirm. The task must belong to the case in liveCase or one of its runs. A task
of another case, a task you may not see and a task that does not exist all show the same sentence, "This is not available
to you", with nothing of the task; an access refusal never shows its technical detail.
The case's context menu
On the case lens, right-click a step of the opened state's flow, or a state of the lifecycle, to see what can be done to the case from there (spec 116 S4). With the keyboard, focus the step or the state and press the Menu key or Shift+F10. The menu is headed by the case and the step or state ("INC-2519 · Wait for the all-clear") and applies to that case only. With no case open, the browser's own menu appears instead.
A step's menu lists, in this order: Restart from here, Retry this step, Skip this step, Restart this state and Go back to this state (the state the step belongs to). A state's menu lists Restart this state and Go back to this state. An item you may not use is not shown (DEC-16, SCRUM-3538), and has no agent command:
- the rights: Retry this step needs the right to resume a case and resolve its incidents; the other items also need the right to change where a case continues;
- restarting a running case (see Restarting a running or waiting case) also needs the right to pause cases: without it, Restart from here, Skip this step, Restart this state and Go back to this state are not shown on a running case;
- the step's run is one you may not open: no item is shown.
When no item is left, a step that holds no person's task (and a state) has no Live menu: the browser keeps its own. On a person's task step the menu still opens, to read the step's tasks; if none of them is shown to you, it stays open and says only "This is not available to you". Every item you may use is listed. One that does not apply right now is disabled and says why, in the same words as the server's dry run:
- the case has ended, or the case itself failed;
- a running case can be restarted and a paused one too (see Restarting a paused case); on either, Retry this step is not offered ("Only a failed step can be retried; this case's flow is running, so choose 'Restart from here' on the step instead");
- a paused case whose flow is still running (its pause did not reach the flow): "INC-2519 is paused, but its flow in Containing is still running; resume the case, then restart it";
- the step: only the failed step can be retried ("…; it failed at Ramp closed"); a step that chooses between paths cannot be skipped; the start, an end, a gateway, a step's boundary event, a sub-flow, a loop's body, one of several raced waits, a step on parallel paths and a step that cannot be reached are not places to continue from;
- the state: Restart this state restarts only the state the case is in now; Go back to this state goes only to a state the case has been in ("INC-2519 has not been in Investigating; a case can go back only to a state it has been in"), never the one it is in now ("The case is already in Containing Test; use 'Restart this state' to start its flow again"), and only to a state that runs a flow of its own.
Restart from here, Retry this step, Skip this step and Restart this state open the restart dialog (see "Restart from here" below). The menu's reasons are guidance: the dialog's dry run is what decides, so something only the server can see (open work at the step, a running child flow) is said there. Go back to this state opens the same dialog: the current state's flow is stopped and kept, and the earlier state's flow starts from its first step; the route out of it is decided again when that flow ends, and case data written since stays unless it is written again.
In the menu, the arrow keys, Home and End move between the items, and typing a letter goes to the next item that starts with it. A disabled item can still be focused, so its reason is read out. Enter chooses an item; Escape closes the menu and puts you back on the step or state. Studio, Live included, is English and reads left to right; names you author keep their own direction. Right to left applies to published interfaces and their components, not to Studio.
Task actions in the menu
On a step of the case that holds a person's task (a user task; spec 116 S15), the menu adds, below the restart items, Work on this task…, Reassign task… and Delegate task…. They act on the case's open task at that step and open it in the task dialog over Live (see "Working on a task from Live"): Work on this task… as it is, Reassign task… on Hand on, Delegate task… on Delegate. The menu reads the step's open tasks of the case's own run when it opens: every open task there that you may open, by the same rules as opening the task itself, so a task waiting in the pool or held by someone else is offered when you may open it, even without the right to see all tasks (spec 116a, SCRUM-3679). A run you may not open is never read.
Items you may not use are not shown: Reassign task… without the right to assign tasks, Delegate task… without the right to delegate (or without that right on this task's process), and no task items at all for a run you may not open, for a step whose tasks you may not see, or when the read is refused. The menu never says no one is working on a step whose tasks you cannot see. An item that is shown says, before you submit anything, why it cannot be used just now:
- "No one is working on this step right now" (no open task at the step; shown only when you may see every task there);
- "The process does not allow this step's task to be handed on; it can only be released back to the pool" (the step is authored "reject only"; the server says so on the task, so you learn it before, never after);
- "This task is already closed".
A task whose own read is refused is not shown either (DEC-16, SCRUM-3538): with one task at the step there are then no task items; with several, that task is left out of the list.
Where the step lets a task be handed on within its pool only, the person picker in the dialog offers the pool's members only, and the server still refuses anyone else. With several open tasks at the step, each item opens a short list first: each task with who holds it ("1. Omar", "2. In the pool, not claimed yet"), at most ten, and how many more are not listed (or "More open tasks here are not listed" past a thousand). When the dialog closes, focus returns to the step you right-clicked.
Reassigning the open tasks of a step, for a group
With no case open, open a state's flow and right-click a user task step (or press the Menu key or Shift+F10 on
it): the menu, headed "Containing · Secure the scene", offers Reassign the open tasks of the 12 cases here…. Its number
is the cases in view at that step, as the figures count them (your filters apply; a case you may not see is never
counted); the dry run then counts the tasks. It is not shown when you may not assign tasks (nor is its agent command),
and is disabled with the reason when no case is there. It is offered only on a step that holds a person's task (every step also has the group restart rows below).
It opens, in the address
(liveGroupReassign=<step>):
- the person picker (people of the workspace);
- a dry run of one batch, made by the server for that person, task by task: Will be handed on (each case and who holds its task now) and Cannot be handed on, and why (for example the step's "reject only" rule, a person outside the step's pool, a closed task, a task already with that person, or your rights on that task). A task you may not see is never listed or counted. Change the person goes back to the picker. Nothing has changed yet;
- a reason (required, at most 1,000 characters) and the phrase it asks for, reassign 12 for twelve tasks;
- each task's own result: Handed to Leila Haddad, or Not handed on with the reason.
Confirming needs the right to assign tasks (the dry run does not). The server checks the phrase itself, makes the dry run again and refuses, with nothing changed, if the tasks that would be handed on differ from yours ("The group changed after your dry run; review it again"). Each task is then handed on by the task service on its own, exactly as from the task dialog: with your rights on that task, the step's rule, its own record and its own result; one task failing never stops another. A summary of the batch (who, the person, the counts) is recorded besides each task's own record. A batch is at most 500 tasks, whole cases at a time, the cases waiting longest first; a case with more tasks than that is taken whole on its own, up to 1,000 (the dry run says when a case has more). Review the next batch leaves out the cases of this one, those whose tasks you may not see included (their tasks are still open at the step, now with the new person). When no clear answer comes back, the dialog says it could not confirm what happened, and Live reads the figures again.
Restarting a group of stuck cases
With no case open, open a state's flow and right-click the step where cases are stuck (or press the Menu key or Shift+F10 on it). Above any task rows, the menu offers:
- Restart the 12 cases stuck here from…, which opens the steps a restart may continue from (the same steps Restart from here allows for one case: never a start, an end, a parallel split or a step inside parallel paths);
- Retry the 12 cases stuck here, which runs the step they failed at again.
"Stuck here" means failed at that step: running or paused cases whose flow in this state failed there with an open
incident, the same group as Group: cases failed here. The number is the cases in view needing attention at that
step (your filters apply; a case you may not see is never counted); the dry run counts exactly. A row is not shown when
you lack its rights (resuming a case and resolving its incidents; for Restart also changing where a case continues;
DEC-16, SCRUM-3538); a row you may use stays visible and disabled, with the reason, when no case in view is stuck there.
An address that opens the group dialog without those rights shows "This is not available to you". Choosing a step opens, in the address
(liveGroupRestart=<step> with liveGroupRestartTarget=<step>, or liveGroupRestartAction=retry):
- a dry run of one batch, made by the server case by case, each with your rights on that case and its own rules (a paused case stays paused and nothing runs while it is; a task someone else is working on needs the right to assign tasks; …): What runs again, in each case (the steps contacting outside systems are marked and named again in a warning: that work is repeated once for each case), Will be restarted (each case, with its own warnings) and Cannot be restarted, and why (for example "You may not restart this case; ask someone who can"). A case you may not see is never listed or counted. Nothing has changed yet;
- a reason (required, at most 1,000 characters) and the phrase it asks for, restart 12 (or retry 12) for twelve cases that will change, typed in the confirmation;
- each case's own result, in the same words as for one case: Restarted · INC-2519 is waiting at 'Wait for the all-clear', Restarted · <step> failed again: <reason>, Not restarted with the reason (nothing changed for that case), or Could not be restarted when something went wrong on the server (nothing changed for that case; a reference to quote is shown beside it). Open opens a case in Live. A restarted case whose own result offers Undo (as it would for one case) has Undo beside it: it opens that case's own Undo (its dry run, a reason and its result, as for one case); closing it returns to the batch's results, where that case then says Undo was tried. When a restarted case offers no Undo, the reason is said beside it ("Undo is not offered: …"). A retried case offers no Undo.
The server checks the phrase itself, makes every case's dry run again, and refuses with nothing changed if the cases that would change, or anything a case's dry run showed (its position, its incidents, its versions, its status, the tasks it would withdraw), differ from yours: "The group changed after your dry run; review it again" (Run the dry run again). Each case is then restarted on its own, exactly as for one case: with its own rights, its own checks, its own transaction and its own record, and Undo where its result offers it (above); one case failing never stops or undoes another. Each case's own record says it was restarted as part of a group and carries the batch's reference; a summary of the batch (who, the step, the counts and that same reference; no case) is recorded besides them; if it cannot be recorded, the result says so and each case keeps its own. A batch is at most 500 cases; Review the next N cases makes a new dry run of the next ones, leaving out the cases of this one that are still stuck (those that could not change, failed again, or were not restarted); the ones restarted have left the group. If the dry run itself cannot be made, the dialog says so in one fixed sentence (nothing has changed) and offers Run the dry run again. Skip, Restart this state and Go back stay one case at a time. When no clear answer comes back, the dialog says it could not confirm what happened, and Live reads the figures again.
From the Monitor, Restart from… on a row of Problems opens that case here, on the flow of the state it is in, with this menu open on the step where it stands. Restart from… under the case's Other actions does the same.
Restart from here
Choosing a restart item opens one dialog, headed by the action, the case and the target ("Restart from here · INC-2519 · Wait for the all-clear"). It works in three parts (spec 116 S5):
-
The dry run. The server works out what would happen; nothing has changed yet. The dialog says, in business words:
- where the case continues, in one sentence ("INC-2519 continues from 'Wait for the all-clear'; 'Ramp usable?' runs again; no outside system is called again"). Skip this step continues from the next step, and the skipped step does not run; Retry this step runs the failed step again, as the case's initiator; Restart this state stops the state's flow and starts it again from its first step;
- Runs again: every step that runs again, in order, each marked when it contacts outside systems, notifies people, runs for the first time or may repeat. A long flow shows the first 20 and "and N more", with Show all N steps;
- Outside work: each step that calls an outside system or notifies someone again. Running a step again repeats that work, as Retry does;
- Case data: each field a step running again writes, with its current value ("riskScore (640) is written again by Assess Risk"). A value you may not see says "value hidden". The data is kept as it is; correct it separately with Change data…;
- Incidents closed as replaced, the case's own incident marked as such (technical text only with the right to see technical values);
- Waits: the waits and tasks created again; a timer waits again from now;
- Run stopped (Restart this state): the current flow is stopped, not deleted, and stays in the case's history as "Stopped by restart";
- Versions and Runs as, then the server's warnings ("Before you confirm") and, when it cannot be done, why.
While the dry run is on screen, the canvas outlines the steps that run again, the step the case continues from marked Continues here and, for Skip this step, the skipped step marked Does not run; a screen reader hears the same steps as a list. When you may not see who the steps run as, Runs as says "Who the steps run as is not shown".
-
Why. A reason is required (at most 1,000 characters); it is recorded with your name. When the dry run says the action cannot be done, no reason is asked and the confirm says why.
-
The outcome. Confirming sends exactly what the dry run saw; the server checks it again. Exactly one outcome follows, in the server's words, announced and linked to the case: "Restarted · INC-2519 is waiting at 'Wait for the all-clear'", "Restarted · 'Ramp usable?' ran and the case continues", "Restarted · <step> failed again: <reason>", or "Not restarted · Nothing in the case was changed." with a reference to quote (and Run the dry run again). Go back to this state says "Moved back to 'Assessment' · CASE-LOAN-0001 is waiting at 'Collect documents'". While the confirm is being sent, no other menu item opens; if the case cannot be read again afterwards, the outcome stays.
If the case changed after the dry run, nothing changes and the dialog says so: Run the dry run again reviews it afresh, keeping your reason. A refusal you are not allowed to see the detail of says "This is not available to you"; other refusals keep the server's wording. If the answer does not arrive (or the server fails), the dialog never claims that nothing happened: it says the case may have changed, and Live reads the case again — check it before trying again. With the keyboard: Menu key or Shift+F10 on the step, Enter on the item, Tab to the reason, type it, Tab to the confirm, Enter. Escape (or Not now) closes the dialog and returns you to the step. The case's flow may be failed, paused, or running and waiting (spec 116 S12).
Restarting a running or waiting case
A case that is running and waits at a task, a wait or a timer (spec 116 S12) is restarted the same way. The restart pauses the case, moves it and resumes it as one action: the dry run says so ("INC-2519 will be paused, moved and resumed as one action"), and the dialog says that confirming pauses the case, makes the change and resumes it in one step, and that it is never left paused. On confirm, the case is paused, the step it waited at is cleared (its wait's subscription or timer removed, its task withdrawn as below), the case is resumed, and it continues from the step you chose: that step runs (or waits) again, followed by the steps after it, exactly as for a failed case. A service step can be restarted on a running case (unlike a paused one): it runs again, and the dry run warns about the outside work it repeats. The outcome reads "Restarted · INC-2519 is waiting at 'Secure the scene'"; the case is running. If anything fails, nothing in the case changes, and the case is still running where it waited.
- What the pause covers. It is the same pause as Pause on the case: every flow the case is running is paused with it (its state's flow, and any other flow it started that is still running), and each pause and each resume is recorded in the case's history, by you, with the restart as the reason. All of it happens within the one action, and nothing stays paused.
- Someone working on the task at that moment. If a person is completing or taking the case's task at the very moment you confirm, nothing changes and the dialog says "The case changed after your dry run; review it again": make the dry run again once they are done.
- The pause right. Restarting a running case also needs the right to pause cases. Without it, the server answers as for a case you may not see; the menu says why before you open the dialog. Retry this step, a failed case and a paused case do not need it.
- Work in progress is withdrawn, as for a paused case (below): the task the case waited at is withdrawn with your reason, and someone else's task needs the right to assign tasks.
- Something that arrives meanwhile. If the case moves on between your dry run and your confirm (a signal arrives, someone completes its task), nothing changes and the dialog asks you to review it again. A signal or a completion that comes after the restart no longer matches anything: the wait it was for was removed.
- Not while a step is being run. If the case's flow is running a step right now (not waiting), the restart is refused: "INC-2519's flow is running a step right now; restart it once it waits at a task or a wait".
- Retry this step is not offered on a running case ("Only a failed step can be retried; this case's flow is running, so choose 'Restart from here' on the step instead").
- A paused case whose flow still runs (the pause did not reach its flow) is refused until you resume the case; it is then a running case, which can be restarted.
Restart this state and Go back to this state work on a running case too: the case is paused, its state's flow is stopped (its tasks withdrawn), the case is resumed, and the state's flow starts again from its first step, running.
Restarting a paused case
A paused case (spec 116 S8) is restarted the same way, and it stays paused: the restart only puts it at its new position, and nothing runs on until someone resumes it. The dry run says so ("INC-2519 stays paused after the restart: nothing runs on until someone resumes it"), and the outcome too ("Restarted · INC-2519 is waiting at 'Secure the scene'; it stays paused until it is resumed"). The new step is entered: its task is created and assigned again, or its wait starts again from now. When you resume the case, its flow goes on from there.
- Work in progress is withdrawn. The task the case waited at is withdrawn (closed, with your reason on it), and the dry run lists it: "Decide's task is withdrawn from Ahmed Saleh, who is working on it". If someone else is working on it, you need the right to assign tasks to withdraw it; without it, the restart is refused with "This step's task is being worked on by someone else; withdrawing it needs permission to assign tasks". The person is named only when you may see their task; a task only assigned to someone reads "Check's task, assigned to Leila Haddad, is withdrawn". Your reason is written on each withdrawn task, under your name, and the dialog says so beside the reason. If someone takes the task after your dry run, the restart asks you to review it again; if they take it (or the task is changing) at the very moment you confirm, nothing changes and the dialog says "The case changed after your dry run; review it again". Every withdrawn task is recorded in the case's audit. The person whose task was withdrawn sees it as closed on its task page ("Task already closed"): no saved-work notice and no task actions such as Hand on or Delegate (spec 116a, SCRUM-3685).
- Only where it then waits. A paused case restarts only at a step where it waits again (a task or a wait). A step from which it would run a service step or end first is refused: "INC-2519 is paused: restarting here would run 'Assess Risk' before it waits again. …". Resume the case first for those.
- Nothing that arrived is lost. If someone completed a task, or a signal arrived, while the case was paused, it is applied when the case is resumed, and the restart is refused until then: "Something arrived for INC-2519 while it was paused and is applied when it is resumed; restarting now would discard it, so resume the case first".
- Retry this step is not offered on a paused case ("Retrying a step is not available while the case is paused; choose 'Restart from here' on the step instead").
The same withdrawal applies to a failed case whose step still had a task, and to Restart this state and Go back to this state, whose stopped flow's tasks are withdrawn. Pausing is not a right the restart of a paused or a failed case needs (a running case's restart needs it: see above). Open work that is not a person's task, or a callback guarded by an API key, still blocks a restart.
Where the figures and chips are drawn
On the flow inside a state, each step's figures ("7 here", visits, durations), the case's chips ("took 18ms", "stopped here · 1m 48s") and each route's label are kept clear of the steps, the steps' names and each other (SCRUM-3687). A step's figures wrap into a short block; they sit below a task and above an event or a gateway, and move to its side or the other side when that place is taken or a route runs through it. A route's label slides along its route, or sits just beside it, to stay off the steps and their names. A pool, a lane or a group never pushes a step's chips out of it; only its titles are kept clear. The words that say where cases are ("7 here", "13 need attention", a case's marker) are placed first, and never more than a short way from their own step, nor nearer another step. Where a step's figures have no free place close by (a small window, a busy flow), they fold into one "+3 figures" chip: hover it, or read it with a screen reader, for all of them, or select the step (click the chip or the step, or focus the step and press Enter); its panel lists every figure. "Here" and "need attention" are never folded, and a block unfolds again as soon as there is room (zoom in, or a larger window). When you pan a step out of view, its chips go with it. With reduced motion nothing on the flow animates, and the places are worked out once the drawing has settled. The fit leaves room round the steps for their names and figures, so none is cut by the canvas's edge. The step's ring says a case is there; the words are on the figures ("7 here", "13 need attention") or, for one case, on its chips.
Dragging the marker onto a step
On the case lens, the chip on the step where the case stands ("stopped here · 12m") is the case's marker, and it can be picked up and dropped on another step of the opened flow, with the mouse, a pen or a finger (spec 116 S11). Dropping it opens the same dialog as Restart from here on that step: the dry run, then a reason, then the confirm. The drop itself changes nothing; only the confirm does, and Not now leaves the case as it was.
While the marker is over a step, it is drawn beside that step (clear of the step, its name and its chip) rather than under the pointer, and the step says whether it can be dropped there: Restart from here when it can, Cannot restart here when it cannot. A screen reader hears the same, with the reason. Dropping it on a step that cannot be continued from opens nothing: the step shows "Cannot restart here: <reason>" for a few seconds, in the same words as the menu's disabled Restart from here ("The flow ends here; choose the step where the case should continue", a step of another state, and so on). When you may not use Restart from here on the case at all (its rights, a run you may not open, or a running case without the right to pause cases), the marker is drawn as a plain chip that cannot be dragged, and there is no drop command (DEC-16, SCRUM-3538). Dropped on no step, nothing changes. Escape while dragging, or leaving the window, puts the marker back and says "Drag cancelled. Nothing changed". The same words are also shown by the marker for 8 seconds (or until you pick it up again), clear of the other chips (N-002). Only one pointer moves the marker at a time; a second finger is ignored. While a restart dialog is open, a drop does not replace it ("A restart dialog is open; close it before dropping the marker"), and while a confirm is being sent it says "A restart is being confirmed; try again when it finishes". Steps inside a pool or a group take the drop like any other. A drop counts only where the canvas is seen: over the details drawer, or past the canvas's edge where a step has been panned out of view, it is no step and nothing changes. If the case moves on while you hold the marker (its step changes), the drag is cancelled and the marker can be picked up again where it is now.
Since the marker can be picked up, pressing on it moves the marker instead of panning the canvas; press beside it to pan. A plain click on it (a press and release without moving) is not a drop, and still clears the chosen step, as a click beside a step does.
The drag offers only what the menu does. Dragging is never the only way: with the keyboard, focus the step and press the
Menu key or Shift+F10, then choose Restart from here. Agents use the command process.live.case.marker.drop with
{ "stepId": "<step>" }, which does what the drop does. It is offered only when some step of the flow would take the
drop and no dialog is open; otherwise it is disabled (busy while a confirm is sent) and its title says why: "A restart
dialog is open…", "A restart is being confirmed…", "No step here can be restarted" or "This case has no position marker
here". Two drops at once open one dialog; a restart dialog, once open, is never replaced by another drop or menu
command — close it first. The marker itself is process.live.case.marker.step.<step>.
Undo a restart
When a restart's outcome offers it, Undo this restart appears under the outcome (spec 116 S7); when it does not, the outcome says why ("Undo is not offered: …"). An undo withdraws the task the restart created, with the same rule as a restart: a task someone else is working on needs the right to assign tasks (S8). It is offered while nothing has run past the restart: the case still waits where the restart left it, or the step it ran failed again. It opens the Undo in the same place, in the same three parts:
- The dry run. Nothing has changed yet. The dialog says where the case goes back to ("INC-2519 goes back to 'Ramp closed', failed, as before the restart"); where it is now; the incidents recorded again (the ones the restart closed, the case's own marked as such) and the restart's own incidents that are closed; the waits removed ("Wait for the all-clear no longer waits for a signal"); for Restart this state and Go back to this state, that the state's new flow is stopped and kept in the case's history; and Outside work: a step the restart ran that called an outside system is named, because undo does not call it back ("'Assess Risk' already contacted an outside system again; undo does not call it back"). Case data written since the restart stays as it is: undo puts back the position and the incidents only. Nothing is created again for the failed position (a failed step had no wait).
- Why. A reason is required (at most 1,000 characters); it is recorded with your name.
- The outcome, in the server's words: "Undone · INC-2519 is back at 'Ramp closed', failed, as before the restart" (for a state action, "… is back in 'Containing Test', its flow failed at 'Ramp closed', …"), or "Not undone · Nothing in the case was changed." with a reference to quote. Closing it closes the dialog.
An undo is all or nothing, and it is done once: a second undo of the same restart is refused. It is refused, with the reason in the dry run, when:
- a step ran after the restart ("'Ramp usable?' already ran after the restart; this restart cannot be undone");
- the case moved on, ended or failed itself, or its position was changed since the restart (for example by Move to another step in Operate) or its incidents changed;
- the case was paused after a restart made while it ran ("… resume it to undo the restart"), or resumed after a restart made while it was paused;
- the restart left the flow at more than one step;
- the task the restart created is being worked on by someone else and you may not assign tasks, or the position has other open work or a callback guarded by an API key;
- something was recorded on the case after the restart (a version move, Fix and retry or another restart), or the case's version changed;
- the restart was made before undo existed.
If the case changed after the Undo dry run, nothing changes and the dialog says so. With the keyboard: Tab to Undo this restart, Enter, Tab to the reason, type it, Tab to Undo the restart, Enter.
After the restart dialog was closed (spec 116d, SCRUM-3686). Open the case, then Other actions → Recover a failed
case → Undo the last restart…. It opens the same Undo (dry run, reason, confirm, outcome) for the case's latest
restart that still stands: the newest restart recorded on the case or on its running flow that has not been undone. The
item says what the undo would do ("INC-2519 goes back to 'Ramp closed', failed, as before the restart"). When that
restart can no longer be undone, the item is greyed with the reason from the list above (for example "'Ramp usable?'
already ran after the restart; this restart cannot be undone"). It is not shown when the case has no restart that still
stands, when the case has ended, or when you lack the rights to undo it (resume cases, resolve incidents and repair a
case's position; the right to pause cases for a restart made while the case ran). A restart usually leaves the case
healthy, so on a case where nothing has failed the recovery group then lists this item alone instead of "Nothing has
failed in this case". Only the latest restart can be undone; an older one is undone after the newer ones. The agent id
is process.live.case.undo-restart (also a command). The Activity tab's history rows still offer no Undo.
Undo of a running restart (FR-024, spec 116 S12). A restart made while the case ran is undone while it runs: the case is paused, put back and resumed as one action ("INC-2519 will be paused, put back and resumed as one action"); the step it waited at is entered again ("'Wait for the all-clear' is entered again: it waits again from now"), and the outcome says "Undone · INC-2519 is back at 'Wait for the all-clear', waiting as before the restart". It needs the same rights as the restart, the right to pause cases included.
Undo of a paused restart (FR-024). A restart made while the case was paused is undone while it is still paused: the step the case waited at is entered again ("'Decide' is entered again: its task is created again and assigned as the step assigns it, and the case stays paused"), and the outcome says "Undone · CASE-LOAN-0001 is back at 'Decide', waiting as before the restart; it stays paused". It is not offered once the case was resumed after the restart (even if it was paused again), nor while something that arrived during the pause waits to be applied. If the case's resume history now holds fewer resumes than the restart recorded (audit records were purged or altered), Undo is refused with "This restart's history can no longer be confirmed, so it cannot be undone": the platform cannot tell whether a resume happened, so it neither undoes the restart nor claims that one did.
After Fix and retry. A case restarted after Move to version N and retry cannot be put back on its earlier version while the restart stands: "This case was restarted after Fix and retry; undo the restart first". Undoing the restart makes the put-back possible again. A restart also never releases the case from Fix and retry's hold (spec 110, owner decision of 2026-10-11): while the flow Fix and retry moved has not finished, the case still cannot be moved or undone by a version's record or a later publish, whether the case was failed, paused or running when it was restarted. Restart this state (or Go back to this state) stops that flow, and a stopped flow has finished, so the hold then ends: a later publish can move the case again. The restart itself still stands on the case, though: until it is undone, the version's record Undo and any other rollback of the case's earlier version moves are refused with "This case's flow was restarted from a chosen step, so its journal cannot be rolled back here; a restart is undone only from the case. Nothing was changed." Undoing the restart brings the stopped flow back, and with it the hold: put the flow back from the case first, and only then can the earlier version moves be rolled back.
Fix a failed case
When a step of a case's state flow failed and the fix has been published as a newer version of the lifecycle (spec 110, SCRUM-3318), the case screen offers Move to version N and retry step next to Inspect failed step, as the first action. For example, CASE-LOAN-0001 failed at Assess Risk in Assessment on version 8; once version 9 is published, the button reads "Move to version 9 and retry Assess Risk". It always targets the newest published version.
The whole way, from the failed case to the fix (spec 110, SCRUM-3253):
- Find the cause. The case screen says what failed, where and why. Inspect failed step opens the step in its state's flow. Until a newer version is published, Move to version N and retry is shown disabled: "No newer version is published. Fix the design and publish it first".
- Edit the design for this case. Fix in Designer (or Edit the design while it runs…) opens the lifecycle editor pinned to the case, at the failed step of its state's flow (see "Changing the design while cases run"). Correct the step there. The fix is always published as a new version: Apply to this case only cannot carry a change to a step inside a state.
- Publish it. In Design, Publish asks what your edit should do (see "After publishing from the failed case" below). Publish and include this case goes straight to the move-and-retry's dry run. Publish for future cases leaves the case where it is, and the report says it is still failed, with a link to it.
- Move and retry. On the case screen (or right after the publish), Move to version 9 and retry Assess Risk shows a dry run, asks for a reason, and gives one of three results (below).
- Check the record. Version 9's record lists the case among the cases moved onto it, and who moved it.
- Put it back, if you must. While the retried step has not completed on version 9 (in practice, after it failed again), Put back on version 8 returns the case and its flow together (see "Putting a case back after Fix and retry" below).
Every step that changes the case is confirmed by you after a dry run, needs its own rights, and is recorded with your name. Publishing never moves or retries the case by itself.
The move-and-retry opens a dry run first; nothing changes until you confirm. The dry run names:
- the case, the state and the failed step ("CASE-LOAN-0001 · Assessment · Assess Risk");
- the versions: the case's ("Version 8 → version 9") and its state flow's;
- what runs again, on which version, and as whom (the case's initiator);
- each open incident it addresses, in business words (the technical text only if you may see technical values);
- what cannot change, and why. When anything is listed there, the confirm stays disabled;
- a warning when the step contacts outside systems (running it again repeats that work), and one when version 9 does not change Assessment's flow (the step then runs as it did on version 8, so the fix was made elsewhere).
Give the reason (it is prefilled "Fixed in version 9" and recorded with your name), then confirm. The case and its failed flow move onto version 9 and the failed steps run again, in one step: either all of it happens or nothing changes. The result is exactly one of:
- Moved to version 9 · Assess Risk is running again: the case continues on version 9;
- Moved to version 9 and Assess Risk failed again, with the new incident's reason: the case stays on version 9, failed at Assess Risk, with a new incident. Fix the design again, publish it, and move and retry once more;
- Not moved, with the reason: nothing was changed in the case. When something went wrong on the server, a reference is shown; Copy the reference and quote it when asking for help. If the step had already started running again when it went wrong, work it sent to outside systems may already have happened and is not called back: the result says so ("Nothing in the case was changed; the step's outside work may already have run."). Check the outside system before you retry again.
The result links to the case in Live and to the version's record, and Show the incident opens the case's Work tab on its state's run. The case screen is read again afterwards. If someone moved or retried the case after your dry run, nothing changes and the dialog says "The case changed after your dry run; review it again": Run the dry run again. A case you may not change, or one that does not exist, reads only "Not available". When no clear answer comes back (the connection dropped, or the server failed), the dialog says "We could not confirm whether the case moved; it is being read again. Check the case before retrying." and offers no immediate re-run. If you leave the screen while it works, the result is still shown as a notice. If a newer version was published after your dry run, nothing changes either ("Version 10 was published after your dry run; review again"): you never move a case onto a version you did not review.
Rights. Moving and retrying needs the rights of Retry on the case's flow (to resume it and resolve its incidents) and the right to resume the case itself. The right to publish is neither needed nor enough. The server checks them before it reads anything, so a case in another workspace, a case you may not see and an unknown case all read the same "Not available", and nothing about them is shown. The dry run needs the same rights as the confirm.
Record. Every attempt that changed the case leaves exactly one audit record (who, the reason, the case and its flow with their old and new versions, the steps, the incidents before and after, and the result), together with the retry's own record, written in the same step. If the record cannot be written, nothing changes. A refused attempt, or Not moved, changes nothing and leaves no record.
The action is not shown (DEC-16, SCRUM-3538), nor is its agent command, when you lack the rights of Retry (to resume a case and resolve its incidents), when the failed step is in a run you may not open, when you may not see its incidents, or when the server refuses the failed flow's dry run. It is shown disabled, with the reason, when:
- the failed step's incidents could not be read just now;
- no step failed (only an incident is open): it is then listed under Other actions;
- no newer version is published ("Fix the design and publish it first"); Inspect failed step is then first. Except when the case already runs the newest version and only its failed flow is behind: see "When only the failed flow is behind" below;
- the newer version no longer has the failed step: use Restart from… to choose where the case continues;
- the case runs its case-specific design: move it onto a published version first;
- the case itself failed, not only its flow (this action cannot move it).
An ended case offers no action. After failed again, Put back on version 8 puts the case and its flow back on the version they came from (spec 110 R4), with its own dry run and reason (next section).
When only the failed flow is behind
A plain move (Publish and include running cases, or Publish and include this case when you may not open the case's failed flow) moves the case only: its state's flow keeps running the version it started on (spec 110 R7, SCRUM-3338). A failed case can therefore already be on version 9, the newest, while its failed Assessment flow still runs the flow of version 8. Then the case screen offers Move the failed flow to version 9 and retry Assess Risk in place of the disabled "No newer version is published".
It is the same action, with the same rights, refusals and dry run, except that only the flow moves:
- the dry run says the case stays ("Version 9, unchanged: the case already runs it") and shows the flow's versions ("Its Assessment flow: version 3 → version 4", the flow versions version 8 and version 9 pin), and what runs again on version 9's flow;
- confirming moves the failed flow and retries its failed steps in one step: either all of it happens or nothing changes. The results are the same three: Moved the failed flow to version 9 · Assess Risk is running again, failed again (the flow stays on version 9's flow, with a new incident), or Not moved;
- after failed again, Put the flow back on version 3 returns only the flow to the flow version it came from; the case stays on version 9 (next section);
- while that flow has not finished, version 9's record does not undo the case's own move onto version 9 (it is skipped with "This case's failed flow was moved by Fix and retry; move or undo the case once that flow has finished, or put the flow back from the case." and Undo from the case), and a later publish does not move the case either, so the case is never separated from the flow it was fixed for. The record does not list you among the people who moved the case onto version 9, because you moved only its flow.
When the flow already runs what version 9 pins, nothing is offered: version 9 did not change that flow, so publish the fix first. The case screen asks the server for the dry run to decide this, so the action reads "Checking the failed flow against version 9…" for a moment. If that check is refused, the action reads "This is not available to you"; if it fails, "The failed flow could not be checked just now." A restart made inside the moved flow (Restart from…) does not release the case: it stays held until the flow has finished or is put back. A group of failed cases (below) never moves a flow alone: such a case is listed with "This case already runs version 9; only its failed flow is behind. Move the failed flow from the case."
Putting a case back after Fix and retry
When the retry failed again on version 9 and you want the case back on version 8 while you investigate (spec 110 R4, SCRUM-3320, owner Q3-A), put it back. The case and its flow always go back together: a case is never moved back while its flow stays on version 9. It is offered in three places:
- Put back on version 8 in the result of Move to version 9 and retry, after failed again (also after a move-and-retry made right after publishing);
- Put back after Fix and retry… under Other actions → Recover a failed case, while the case's flow is failed;
- Undo from the case in version 9's record, beside a case its Undo skipped (see "A version's record" below). It
opens the case in Live with the put-back's dry run open (
liveFix=undo, with the flow the move was made on inliveFixRun). When it cannot open there, the case screen says why ("This case has ended, so there is nothing to put back", "That flow is not one of this case's; nothing was opened"); without the right to resume cases, or for a flow in a run you may not open, it says "This is not available to you".
The first two are not shown without the right to resume cases (DEC-16, SCRUM-3538).
The put-back opens a dry run first; nothing changes until you confirm. It names the case, its state and the step ("CASE-LOAN-0001 · Assessment · Assess Risk"), the case's versions ("Version 9 → version 8") and its flow's, and what happens: "Assess Risk stays failed on version 8, with its incidents; nothing runs again." When version 9 did not change the state's flow, it says "Version 9 did not change Assessment's flow, so only the case goes back." Give a reason (it is required, not prefilled, and recorded with your name), then confirm Put back on version 8. The result is one of:
- "Put back on version 8 · Assess Risk is still failed there, with its incidents.": fix the design, publish it, then move and retry again;
- Not put back, with "Nothing was put back; the case is still on version 9." and a reference to quote when something went wrong on the server.
It links to the case and to the version's record. It cannot be put back, and the dry run says only why, with nothing to confirm and no plan of the move (the case may have moved on since), when:
- the retried step already ran on version 9: "Assess Risk already ran on version 9; this case cannot be put back";
- the state's flow has finished ("Its Assessment flow has finished; this case cannot be put back") or was cancelled;
- the case moved again after Fix and retry, ended, or failed itself (not only its flow);
- the case was restarted after Fix and retry: undo the restart first (see "Undo a restart").
Only the latest Fix and retry on a flow can be put back ("No Fix and retry on this run can be put back." otherwise), and only a move made since this release recorded what is needed to reverse it. If the case changed after your dry run, nothing changes ("The case changed after your dry run; review it again"). Putting back needs the right to resume the case and its flow, checked by the server in the same order as the move; a case you may not change reads only "Not available". Each put-back is recorded with your name, the reason and both versions; if the record cannot be written, nothing is put back.
After publishing from the failed case
When you edit the design from the failed case (Fix in Designer, or Edit the design while it runs, so the editor is opened for that case) and publish from Design (spec 110 R3, SCRUM-3319), what happens to the case depends on your choice in What should your edit do?. Whether the case's flow is still failed is read again when you choose, as you may see the case.
- Publish and include this case: the card says that the case's flow failed at a step and that a dry run comes
first. After publishing, the same move-and-retry dry run as above opens, not the plain move (which would leave the
failed flow on its old version). It says "Version 9 is published. CASE-LOAN-0001 is still failed on version 8 until
you confirm the move below.", with the reason prefilled "Fixed in version 9". If someone published a newer version
meanwhile, the dry run says "Version 10 was published after version 9; confirming moves the case onto version 10, the
newest." Once you confirm, the result is the publish's report: Version 9 published at HH:MM, then exactly one of
the three results above.
- Closing the dry run without confirming, or a refusal when you confirm ("The case changed after your dry run", or another reason; nothing was changed), ends in the publish's report, which says the case is still failed.
- When no clear answer comes back, the dialog keeps Version 9 published with its record, and says that CASE-LOAN-0001 may have moved: check the case before doing anything else.
- Without the rights to move and retry the case, the dry run reads "Not available"; closing it ends in the publish's report with the still-failed line.
- Publish for future cases: the case stays where it is. The publish's report says "CASE-LOAN-0001 is still failed at Assess Risk on version 8" with "Move to version 9 and retry Assess Risk from the case in Live", and a link, CASE-LOAN-0001 in Live, to the case, where the action is offered.
- Publish and include running cases, or Publish and include this case when the failed step is in a run you may not open: these are the plain move. The case moves onto version 9, but its failed flow stays failed on its old version (it is not retried). The report then says "CASE-LOAN-0001 is still failed at Assess Risk on version 9" with "Moving the case did not run its failed step again; open the case in Live" (for a run you may not open, "ask someone who can"), so the move never reads as a fix.
The report never says the case is fixed; only "Moved to version 9 · Assess Risk is running again" means it continues. Show the incident opens the case in Live on the version it runs, on its Work tab. The "still failed" line comes from reading the case as you may see it: a case you may not see, one that no longer exists, or a case of another lifecycle is not mentioned at all, and a case that is not failed adds nothing. When the failed step is in a run you may not open, the line says "The failed step is in a run you may not open; ask someone who can." instead of offering the move. A case that is not failed, or that runs its case-specific design, is published exactly as before.
A group of failed cases
When many cases failed at the same step for the same cause (spec 110 R5, SCRUM-3321), move and retry them together
instead of one at a time. Open the state's flow, select the failed step, and in its panel choose Group: cases failed
here (offered when cases need attention at that step). The group reads "Failed at Assess Risk in Assessment", is a
chip in the filter bar (removed on its own or with Clear filters), and is in the address (f.failedState,
f.failedStep). It holds the running cases that still wait on their Assessment flow while that flow is failed at
Assess Risk; your other filters still apply, and a case you may not see is never in it.
Above the diagram, Move to version 9 and retry Assess Risk for these 12… opens a dry run of the group
(liveGroupFix=retry in the address). It is not shown without the rights of Retry (DEC-16; the address then shows "This
is not available to you"), and is shown disabled, with the reason, when the group is empty. The server makes the same dry run as for one case, for each case of the group, with your rights on that
case:
- Will move and retry: each case and the version it leaves ("Version 8 → version 9"), and any other failed step of its flow that runs again too ("also retries Notify Bureau");
- Cannot move, and why: each case that cannot, with its reason, for example "This case runs its case-specific design; move it onto a published version first" or "You may not move and retry this case; ask someone who can";
- a warning naming the steps that run again and contact outside systems: that work is repeated once for each case;
- a warning when version 9 does not change Assessment's flow for some of the cases.
Nothing has changed yet. Give the reason (prefilled "Fixed in version 9"), then type the phrase it asks for, retry 12 for twelve cases that will move, and confirm. The server checks the phrase itself, resolves the group again, and refuses with nothing changed if the cases that would move, the versions they run, or the version to move onto differ from your dry run ("The group changed after your dry run; review it again", or "Version 10 was published after your dry run; review it again"): Run the dry run again.
Each case is then moved and retried on its own, one after another, exactly as for one case: with its own rights, its own checks, its own record and its own result. One case failing never stops or undoes another. The result lists each case:
- Moved to version 9 · Assess Risk is running again;
- Moved to version 9 · Assess Risk failed again, with the reason: the case stays on version 9 with a new incident;
- Not moved, with the reason (nothing changed for that case; a reference is shown when something went wrong on the server).
Open opens a case in Live; the result also links to version 9's record. A summary of the batch (who, the counts) is recorded besides each case's own record; if it cannot be recorded, the result says so and each case keeps its own.
A batch is at most 500 cases. When the group has more, the result offers Review the next batch: a new dry run of the next cases (those this batch could not move on are left out), with its own phrase to type. A batch where no case can move offers Review the next batch at once. Reloading the page starts again at the first batch; cases already moved have left the group. When no clear answer comes back, the dialog says "We could not confirm what happened to these cases; they are being read again. Check them before retrying." and offers no immediate re-run.
Keyboard
Tab to a card and press Enter (or Space) to choose it; inside an opened state, do the same on a step. Each card's button opens the flow inside that state. On the case lens, the Menu key or Shift+F10 on a card or a step opens the case's context menu (see "The case's context menu"). Its Restart from here is the keyboard way to do what dragging the case's marker onto a step does (see "Dragging the marker onto a step").
The dialogs of "Fix a failed case", Move CASE-LOAN-0001 to a newer version and retry, Put CASE-LOAN-0001 back on the earlier version and, for a group, Move these cases to a newer version and retry Assess Risk, work the same way from the keyboard: Tab moves through the dry run, the reason, the typed phrase (for a group) and the confirm, and Enter confirms. The result takes the focus on the line that says what happened to the case, and a refusal takes the focus where it is said. Escape, or Not now, closes the dialog before you confirm; while it works, the dialog cannot be closed.
The details panel
- Nothing selected: running, needing attention, completed and all cases, plus the median and 90th percentile from start to finish and the completion rate. When a version in view has a case service level (spec 124), also SLA at risk and SLA breached: the open cases in view at risk of missing it, and the ones that already did. Without a service level these tiles are not shown (never a 0).
- A state, in this order:
- its name, with Needs attention when any case here needs someone;
- here now and needing attention (active cases), and the longest current wait;
- what the open cases are waiting on (needs attention, a person's task, a timer, a message, signal or record event, otherwise running or queued);
- the cases here, longest first: a list of rows, each with how long it has been waiting and an arrow; choose a row to open that case. A case is named by its reference; one without a reference reads "A case without a reference", never an id. References are not unique: two cases with the same one are told apart by when they started (or came here), here, in search results, in a group's cases and in a dry run. When more cases are here than the list shows, Show all N cases here opens Live's case table on the cases here now (any other filters stay), without changing the report tiles you chose. While a group is on another state it is disabled, with the reason ("Clear filters to list every case here");
- where cases went next, each route as "18 of 30 (60%)" of the 30 exits from the state, then Open state flow and the two Group actions;
- History: visits and time here: a line saying what the figures cover (the version or all versions, the group, the time range and how many completed visits, and the sample when the read is sampled), visits, the median and 90th percentile of the completed visits, and their spread. A figure that cannot be produced reads "Unavailable" with the reason (no visit has finished, no case is here now).
Opening a state
Open state flow, on a card or in the panel (or double-click a card that has one), replaces the diagram with the state's own flow, drawn read-only. A double-click never zooms the diagram, and below 1600px the details drawer makes room for itself only after a double-click could have ended, so the card stays under the pointer (SCRUM-3680):
- steps with cases on them are highlighted, and carry their counts and median time;
- each sequence flow shows how many runs took it, as the engine recorded it, so parallel branches are counted exactly;
- a step's time runs from when it was entered to when that same branch completed it.
The breadcrumb returns to the lifecycle. A failed state-flow run whose case is still in the state counts as needing attention at the step where it stopped.
A group of cases
The filter bar under the toolbar narrows everything on the screen to a group of cases: the diagram, the steps inside a state, the panel and the report. You can filter by:
- the case reference or title;
- started from / to (one day when both are the same; the workspace calendar's days);
- a state the cases are now in (running or paused there) or passed through;
- status;
- what running cases are waiting on: needs attention, a person's task, a timer, a message or event;
- SLA at risk or breached (offered when a version in view has a case service level): only the open cases at
risk of missing their service level, or that missed it (
f.sla=risk); - failed at a step of a state's flow (from that step's panel, Group: cases failed here; spec 110 R5): see A group of failed cases;
- the version (with All versions).
How it reads:
- The breadcrumb says the group in words and how many cases it holds, e.g. "Passed through Containing · 12 of 24 cases".
- Each filter is a chip that removes it. Clear filters removes them all.
- A group with no case says "No case matches these filters" instead of drawing an empty diagram.
- In a state's panel, Group: cases that passed through and Group: cases here now make that group.
- The report's Cases in view tile lists the group's cases, newest first, a page at a time. A row opens the case.
Switching to This version drops a version filter, and drops a state this version does not have. A group that cannot be read offers Clear filters.
Live's case table
Cases in the toolbar opens Live's own table of the cases in view: the same group and the same versions as every figure, with the filter bar above it. It replaces the diagram until Back to the diagram (or Cases again). Each row shows:
-
the case's reference and title;
-
Where it is: its current state, and the task it is at when it has open work (the oldest open task);
-
Status: what it is doing (Running, Paused, …) and Needs attention when someone is needed;
-
Waiting: how long it has been in its current state (— once it ended);
-
Owner: the person its open work is assigned to, with + N unassigned when N of its open tasks are held by nobody ("Sara Al-Rashid + 1 unassigned"); Unassigned when nobody holds any; Several people when its open tasks are with different people; — when it has no open task. Who started the case stays in the case panel;
-
Version: the version it runs, or its case-specific design with the version it is based on;
-
SLA (when a version in view has a case service level): On track, At risk, Breached while it runs, Met or Missed once it completed, Ended when it was cancelled or failed (no time shown), Not set when its version has none, with the time left ("3h 10m left"), over ("over by 2h"), to spare or missed by. Working time is shown in hours, never days, and marked "working time".
The Live status and the Lifecycle data fields answer different questions for a cancelled or failed case: Live says Ended (it neither met nor missed a target it never finished), while Lifecycle data's SLA breached still says whether it ran longer than its target before it ended (Yes or No), so a report can count cases that breached and were then cancelled. Both measure up to the moment the case ended.
Sort orders the table: Newest (the default), Needs attention first (then the longest waiting),
Waiting longest or, with a service level, SLA first (breached, then at risk with the least time left, then on
track, missed, met, not set). The table pages 25 cases at a time. A row opens the case in the case lens; Back to all cases
returns to the table. The table, its sort and its filters are in the address (liveCases=1, liveCasesSort), so a
reload or a shared link opens the same table. It shows only cases you may see, with their owners; a case you may not
see is never listed or counted.
Moving running cases
Migrate in the toolbar opens Live's move dialog for the running cases in view, to the latest published version: a dry run first (Will change / Cannot change yet), then Apply to N, with Undo. With all versions in view and no filter, every running case moves, in batches of at most 500. Migrate is not shown when you may not move running cases (DEC-16), and is disabled, with the reason, when no running case is in view or when the cases in view already run the latest version. The same goes for a group's Move these N to version….
The Live view shows only the cases you may see. A case whose access was taken from you is in no figure, list or search. This is the same rule as the lifecycle data on screens.
Changing the design while cases run
Edit the design while it runs… on a case, or Edit the design for these N running… on a group, opens the lifecycle editor at the place you were looking at (SCRUM-3314):
- With a state's flow open in Live, the editor opens that state's flow, with the step you had selected in it selected (when the draft's flow still has that step).
- Otherwise, with a state selected in Live, it opens that state's flow; from a case with nothing selected, the flow of the state the case stands in now.
- With nothing selected (a group), it opens the Design map, as before.
- A state the working draft no longer has gives way to the next one (an open flow to the selected state, then to where the case stands); when none is in the draft, the Design map opens with nothing selected. A state with no flow of its own in the draft opens the Design map with that state selected; Open flow in the inspector then opens its flow.
- A case that runs its case-specific design opens the Design map with the state selected (the editor first loads that design; Open flow in the inspector then opens the state's flow on it, with a note above the flow saying "Starting from {case}'s case-specific design").
- Review missing outcome on a case opens the editor the same way.
- Fix in Designer on a case that needs attention edits the design for that case, at the failed step of its state's flow (the step is selected); for a case on its case-specific design, at its state on the Design map. It needs the right to edit the lifecycle design; without it the button is not shown (DEC-16), and neither is Declare the outcome in Designer nor the Fix in Designer of an incident under Work. Under Work, each open incident's Fix in Designer otherwise goes the same way.
- In a state's flow, Back to Live stands in the bar above the flow and the header's line names who the edit is for. Publish is disabled there while editing for running cases ("Publish from Design to choose what happens to the pinned cases"): Publish in Design opens Design, pin kept, where Publish… asks what happens to them.
- The cases are pinned: a marker on each state shows how many of them stand there.
- A banner says where they are. It warns when your edit removes a state where some of them stand, and notes when the case runs an older version than the one the draft is based on.
- Back to Live returns to Live exactly as you left it — from the Design map or from a state's flow: the same version or all versions, KPI choice, group, selected state, open flow and step, and open case. Stop editing for these cases (Stop editing for this case for one case) drops the pin: the editor stays on the shared draft and the cases are no longer marked.
- The editor's address carries none of Live's choices, and Live's carries none of the editor's (its selection and the pin). The same holds for the Live and Design mode tabs, with one thing carried across (spec 095 FR-047): the selected state. A state selected in Live is selected in Design (when the draft still has it; Verify, Debug and Flow open with no state selected), and the state selected in Design is selected when you return to Live, which also gives back the open case, the filters and the KPI choice you left.
- Each state stands in the same place in Design and in Live: Live draws the version's stored layout (spread evenly, because its cards are larger), and arranges the diagram itself for a lifecycle that was never arranged in the designer, or when the stored layout would have to be spread more than three times to fit Live's larger cards and their route labels (long labels or counts); positions may then differ from Design.
- With a state selected, Case variables above the inspector opens the lifecycle's case file without deselecting the state (spec 095 FR-048).
Publish… then asks where the change applies, with the four cards of Where should this change apply? (below). Review impact opens the publish review. When you include running cases, after publishing comes a dry run against the new version:
- Will change lists the cases that can move, by reference. Cannot change yet lists the rest, with why.
- For each removed step, Continue them at… chooses where those cases go on. A case whose flow is still running inside a removed state cannot move until that flow ends.
- When a case would move off a removed step, you confirm that first.
- Apply to N, skip M changes the cases that can move; the skipped ones stay on their version and are listed with why. After a publish, the result is the publish's completion report (below), which carries the one named Undo. Applying needs the right to move running cases; without it, Apply says so.
A move without a publish (Move these N to version V…, or Migrate) offers its one Undo right after applying, while the dialog is open, and it says what it reverses: "Undo: move 12 cases back to version 2" (or "back to the versions they ran" when they came from different ones). It puts the changed cases back where they stood (and lists any it could not), and the version stays published.
Every move in a dry run names both sides from their case-specific design: "v2 · Containing → v3 · Containing Test" for a state renamed in the new version, or "Stays at Reported · v1 → v2". A case on its case-specific design is named "its case-specific design, based on v2", never by its internal number.
When publishing needs a typed confirmation ("publish anyway"), the review opens at its top with its heading focused; the typed field comes after what the review says and is not focused.
A typed confirmation is asked only when running cases stand on something the edit removes or changes underneath them. Renaming a state is a label change: it publishes without the confirmation, even when the state runs a flow of its own and cases are running. Removing a state where cases stand, or changing the steps inside a state's flow where work may be waiting, still asks for it.
Cases already running in a process's publish review counts only the running cases you may see: "3 running cases you can see", or "200 or more running cases you can see". Cases you may not see are never counted or named, and no "hidden" total is shown. When a step the new version removes holds some of your visible cases, the review names the step and how many of them stand there; they stay on their current version until they finish or are moved. If you may see none of the process's cases, the review is not refused: it says "Not shown with your access", with no number. When the count cannot be determined, it says "an unknown number of cases already running"; when that is because your access could not be checked right now (your groups could not be read), it says "Your access could not be checked right now. Try again shortly." instead. Nothing needs to be granted for it. The typed "publish anyway" is still asked whenever any running case, visible to you or not, would be cut off by the change.
Where should this change apply? Publishing from Live asks this with four cards:
- Apply to this case only: nothing is published.
- Publish for future cases.
- Publish and include this case (or "these N cases").
- Publish and include running cases.
A card that does not apply stays visible, disabled, with its reason. Below the cards, Proposed design by case group shows what each group of cases gets (this case or these N cases, the other running cases or all running cases, and future cases), and one line says the choice; both change with the card. Review impact opens the publish review. When you include running cases, they move at most 500 at a time: after a batch, the result says "500 of 600 moved", and Move the next 100 finds the next cases you may see that are not yet on the new version, leaving out those an earlier batch could not move. Each batch is resolved and re-checked on the server.
The lifecycle's publish review (spec 105) opens before every lifecycle publish, including a safe change. A safe change confirms with Publish version N, with nothing to type. The review has three parts:
- Changes. Grouped as Cases already running, New cases, The lifecycle, one group per state, and Not checked. Each line says whether it was Checked (against the current version), is Not checked (and why), or is Blocked. Each change is named by its state or step and typed: label, data or binding, routing, work continues, work restarts, work moves, or undetermined.
- Affected cases. The running cases you may see.
- Warnings.
The review opens without the right to see running cases. If you may not see every case of the lifecycle, any breaking change asks for the typed "publish anyway", and the review says "Impact projection: not shown with your access" under Not checked. When no running case you can see stands on a removed state, the review says "Running cases you cannot see may be on removed steps", with no number. So the review never tells you whether cases you cannot see exist. The server applies the same rule when you publish through the API or an agent. If running work changes between your review and your click, so that the publish now needs the typed confirmation, nothing is published, and you are asked to publish again to review it.
After publishing, every lifecycle publish ends in a completion report, even when no case moves. It reports two events:
- "Version 8 published at 10:42";
- what happened to running cases: "2 moved to version 8" ("500 of 600 moved" for a batch, with "600 moved so far" across batches), "No case was chosen to move", "These cases already run version 8", "No case was moved: the dry run was closed", or "Version 8 is not active for these cases yet", with the reasons from the dry run.
After an Undo, the report keeps the move and adds a third event: "2 moved back to version 7", or "The undo was refused" with the reason. Following any of the report's links closes it, and so does changing view.
It links to:
- The moved cases, which opens Live on that version with the group Moved onto version 8 (
f.moved=8). When nothing moved, the link says why instead. - Change record: the version's record (below).
- The design: the published version on the canvas.
A case running its case-specific design that you publish and include gets the same report after its move: "INC-2401 moved to version 8", or "Version 8 is not active for INC-2401 yet" with the reason, and the case's own Undo (for example "Undo: return INC-2401 to its case-specific design, based on version 7"). When cases moved, the report's Undo says what it reverses, for example "Undo: move 2 cases back to version 7". It moves only cases whose last move landed on that version, so a case moved on since is skipped with the reason.
A version's record opens from the report, or from Version N record on the lifecycle page (/workspaces/{ws}/lifecycles/{id}/versions/{N}). It shows:
- who published the version and when;
- what changed compared with the version before, for the lifecycle and for each state, in the same words as the publish review. Anyone who may view the lifecycle sees this.
- the cases moved onto it, by reference, and who moved them ("2 moved by Sara on 9 Oct"). A case moved by Move to version N and retry (spec 110) is listed too, with whoever confirmed the move. The count includes cases of any status, and cases since moved on to a later version. If you may not see any case, it says "Not shown with your access", with no number. "Movers may be incomplete" is shown whenever the list of movers might be missing someone; it is always shown to readers who cannot see every case.
Undo the moves onto version N needs the right to publish the lifecycle and to move running cases; without them it says why ("Not available with your access" when you may not see the cases). It asks first: "Move the running or paused cases still on version N back to the versions they came from — up to 500 now. Version N stays published." The result says how many moved back so far, and when nothing is left the Undo says "Nothing left to move back". It moves running or paused cases still on the version back to the version they came from, at most 500 at a time ("Undo the next 500"). Each case follows its own history, so a case moved from 8 to 9 and back to 8 returns to 9. Cases it could not move back are listed with the reason, or counted when you may not act on them, and the next Undo moves past them. Version N stays published, and new cases still start on it.
A case moved by Move to version N and retry is never moved back by this Undo, because its flow moved with it and would be left behind (spec 110 R4). It is skipped with "This case was moved by Fix and retry; put it back from the case." and an Undo from the case link, which opens the case's own put-back (see "Putting a case back after Fix and retry"). The link names the flow the move was made on only when you may open it.
Move these N to version V… on a group applies the current version to the group's running cases in the same way, without editing anything. It is offered when some of them may run another version, and it keeps the group's own status filter.
Every run is recorded in the audit log, with who ran it.
Applying an edit to one case only
When the editor is open for one case, Publish… asks What should your edit do? The first choice, already selected when it is allowed, is Apply to this case only — nothing is published: the case continues on the edited design, while every other case and every new case stays on the published version. Make a dry run for this case shows what changes.
- What may change: anything at the lifecycle level: the routes between states, their conditions, state names, end states and the case's fields. The steps inside a state may not change for one case, and a new state with steps of its own cannot be added. If the edit changes the steps, the dry run says which state and suggests publishing a version instead.
- Dry run first: a dry run shows what changes for the case. Then Apply to this case moves it.
- One Undo, named: the result offers a single Undo that says what it reverses, for example "Undo: return INC-2522 to version 3". The editor's own undo covers unsaved edits only, so it has nothing to reverse after an apply.
- The shared draft is put back. The edit belongs to the case only. As soon as it is applied, the working draft is put back to how it was when you began editing for the case ("The working draft is back to how it was when you started editing for INC-2522 (at 14:32)"). The same happens however editing for the case ends — Back to Live, Stop editing for this case, Exit, the Live or Monitor tab, the browser's Back button, a link — and the editor then shows the shared draft again, so nothing of the case is left to be saved for everyone. To keep the edit for everyone as well, choose Keep this edit in the draft as well (a separate save), then publish it.
- An edit not applied yet is not dropped silently. Leaving — by the editor's own controls, the browser's Back button or a link — first asks "Your edit for {case} is not applied yet. If you leave now, this edit is discarded. The shared draft stays as it was, and {case} keeps the design it runs." and offers Apply to {case} first or Leave and discard. Apply to {case} first opens the apply dialog wherever you are editing for the case — on the Design map or in a state's flow, where Fix in Designer lands. Closing the tab or the browser while the draft holds a saved edit for the case shows the browser's own leave-page prompt; if you leave anyway, Studio tries once to put the draft back as the page closes. Large drafts are not sent on page close; they are put back on the next pin of the same case in that tab if nobody has saved since — as is a put-back that fails, for example offline. While editing for a case, Exit never offers a plain "Save and exit", and saving waits until the draft as it was at the start has been read.
- If someone else saved the draft meanwhile (possibly you, in another tab), nothing is written: the result — or, after leaving, a note at the bottom of the screen — says so, and the editor shows the draft as saved. Put the draft back anyway replaces the changes saved since you started, after a confirmation; Leave the draft as it is keeps them. While the draft is being put back, the result cannot be closed.
- Publishing does not include it. The editor and the case say so: "This edit runs on {case} only. Other cases and new cases are unchanged, and publishing the working draft will not include it."
- A further edit for the same case starts from the case's case-specific design, reloaded after every apply, so each edit adds to the ones before. The banner says "Starting from {case}'s case-specific design (based on version N)", and Start from the shared draft instead goes back to the shared draft (applying from it then replaces the case's earlier edits). Publishing from there would include the case's design for everyone, and the publish dialog says so. When that design was built on an older working draft, the banner says so and keeping it in the draft or publishing it is not possible (it would undo later changes to the shared draft); it can still be applied to the case.
- After a further edit, Undo says "Undo: return {case} to its previous design (before this edit)".
- Unsaved work made while editing for a case is not kept in this browser for recovery.
- How it shows in Live: the case is labelled Case-specific design · based on vN in lists and on the case itself. It counts under the version it came from (vN) on the diagram, in the report and in groups. Its own lens draws its case-specific design.
- Moving it back: Return to published version N… (or Move onto published version N… for a newer one) on the case moves it onto any published version, through the same dry run, apply and undo. If you publish while that case is pinned, Publish a new version for new cases, and move this case onto it does the same with the new version.
- Moves of many cases leave it alone: "Apply to all running", "these N" and "Move N to version V" skip a case on its case-specific design and list it with the reason.
- Version numbers: each case-specific design uses a version number of its own, which is never shown. Published version numbers can therefore skip a number.
Who can do it:
- The workspace setting: an administrator turns on process.live.case-design for the workspace (off by default).
- Applying needs the right to publish the lifecycle and the right to move running cases. Without one of them, the choice is shown disabled, with the reason.
- Moving back and Undo need the right to move running cases. They work even after the setting is turned off, so no case is left behind. The exception is an Undo that would put the case back on its case-specific design: that counts as applying again.
- Audit: every apply, move back and undo is recorded in the audit log in the same transaction as the move.
Choosing the KPIs
Customize view in the Live toolbar opens what the diagram and the report show (the address
records it as liveCustomize=1). Every change applies at once; Done or Escape closes it. The
browser's Back does not close it (opening it replaces the address rather than adding a step, as the
report does); opening or leaving a case closes it.
- On the diagram: three slots, one KPI each, shown on every state card. The steps inside an opened state show the ones that apply to steps. Change lists every KPI: choose one to fill an empty slot; when the three are full, you are asked which one it replaces (or Cancel). Replace on a slot does the same from the slot (a KPI already in another slot is refused, with the reason); Remove empties it.
- Presets: Operational workload (cases here now, needs attention, visits; states colored by cases here now; routes labelled with the cases that took them) and Duration analysis (median and 90th percentile time in state, share of all process time; states colored by median time; routes labelled with the share of cases leaving). A preset sets the slots, the coloring and the route labels together; the one in force is shown as chosen.
- Color states by metric: the bar under each non-terminal card shows that KPI, as a share of the highest value among those cards (in the warning color above 60% of it; a terminal card draws no bar and does not set the scale). A legend above the diagram names the KPI, its unit (cases, visits, %, time; left out when the KPI's name already says it) and the scale from the KPI's zero ("0", "0%", "0s") to that highest value. When every state is at 0 it says so ("All states are at 0", or "No case is here now").
- Route labels: cases and share, cases only, share only, or the condition alone.
- In the report: the tiles of the report.
Every KPI shows where it comes from:
- Live: read from the engine's log for the cases in view. These are here now, visits, median / 90th / mean time, share of time, rework (re-entries) and needs attention. On a state, rework counts a case coming back. On a step, it counts the run entering the step again after it had left it, by completing it or losing an event race (a loop). Branches arriving at a join and a retried step are not rework. A loop back through a parallel join counts once.
- Disabled, with the reason:
- business time, wait before the next state, task lag and task work time need lifecycle time tracking, which Inflow does not record yet; there is nothing to set up (marked Not tracked yet);
- no plan is kept for lifecycle states (marked Not recorded).
- SLA at risk here and SLA breached here (spec 124, live): of the cases in a state now, those at risk of missing the case service level, and those that missed it. Without a service level in view they read "No service level set".
The report
Report in the toolbar opens the report under the diagram. Its tiles are:
- cases by status;
- cycle time (median, 90th, slowest, with its spread);
- started and finished per day over the last 14 days, by the workspace calendar's days (finished means completed, failed or cancelled; UTC when the workspace has no calendar);
- where the time goes;
- open cases by age;
- rework and needs attention by state, each in its own list;
- SLA: breached and at risk (spec 124): the open cases in view against the case service level, and the states that hold them; "No service level is set for the versions in view" without one.
Every tile covers the same cases as the diagram, so it follows This version / All versions. When the durations come from a sample of the most recent cases, the report says so.
The Monitor
Monitor, next to Live, shows how the published version is doing. Before the process is published it is disabled, with "Available after publishing". There is nothing to turn on: time insights are always on.
Every figure is computed when the Monitor opens, from the version's cases that you may see. Debug runs are left
out. A case you may not see is in no count, mean or total. You need the PROCESS_INSTANCE_VIEW right, globally
and on the process.
It shows:
- Running, Completed, Failed, Overdue tasks and Incidents. Running notes any suspended cases, and Completed any cancelled cases. Overdue tasks counts open tasks past their deadline adjusted for SLA pauses: the time a task's SLA clock was paused moves its deadline later, exactly as in Process Task KPI (SCRUM-4639). Incidents counts open incidents. Overdue tasks is the only SLA figure; there is no "At risk" figure yet.
- Cycle time: mean, median (p50), 90th percentile (p90) and mean in business time, from start to end, over the completed cases.
- Wait vs work: how long tasks waited before someone worked them, against the time spent working them (the task lag and work time of the lifecycle time KPIs). Tasks with no recorded ownership history are not counted, and the card says how many.
- Slowest steps: the five steps with the longest mean time per finished visit.
- Problems: cases that failed, have an open incident or have an overdue task (open, past its pause-adjusted deadline), with the reason. Up to 50 are listed; the subtitle says how many there are in all. For a lifecycle, each row has Restart from…, which opens the case in Live with its context menu on the step where it stands (spec 116 S4). Without the right to resume a case and resolve its incidents it is not shown (DEC-16).
- Steps: every step a visible case has reached, with visits, finished, open, mean / p90 per visit and overdue tasks (open, past the pause-adjusted deadline). A step also counts the overdue tasks of a production run linked directly to the case at that step, such as a lifecycle state's own run, so a lifecycle's steps show its tasks.
A figure that cannot be computed says why instead of showing 0:
- no finished case: "No case of this version has finished yet.";
- no finished visit to a step: "No visit to this step has finished yet.";
- visits whose events could not be paired: "N visits could not be paired from the event log." A step that has timed visits as well is marked Partly timed;
- no task with recorded ownership: the wait and work figures give the reason.
A version with no case you may see shows No activity yet ("No case of this version has started yet. The figures appear here as soon as one does."). If the figures cannot be read, it shows Monitor data unavailable with the error. Neither state offers to turn anything on.
Links
Every choice is in the address, so a reload or a shared link opens the same picture:
| Parameter | Meaning |
|---|---|
pop=all |
All versions (absent: this version) |
liveState=<id> |
the selected state |
liveOpen=<id> |
the opened state |
liveStep=<id> |
the selected step inside it |
liveCase=<id> |
the case lens |
liveTask=<id>, liveTaskAction=hand-on|delegate |
the task dialog over the case lens (spec 116 S14) |
liveMenu=1 |
with liveCase: opens the case's context menu once, on the step where it stands, then leaves the address (spec 116 S4) |
k.shape=a,b,c |
the KPIs on each shape (absent: visits, median, 90th) |
k.heat=<kpi> |
the KPI the states are colored by (absent: share of time) |
k.route=count|share|none |
the route labels (absent: cases and share) |
k.report=a,b |
the report tiles (absent: status, cycle time, per day) |
liveReport=1 |
the report is open |
liveReport=cases |
the report is open on the list of the cases in view (older links; Show all N cases here now opens the case table) |
liveCases=1 |
Live's case table is open on the cases in view |
liveCasesSort=attention|waiting |
the case table's order (absent: newest first) |
liveCustomize=1 |
Customize view is open |
f.text, f.from, f.to, f.on |
the group: reference/title contains; started from / to / on (YYYY-MM-DD) |
f.state, f.mode=now|passed |
the group: a state the cases are now in or passed through |
f.status, f.waiting, f.version |
the group: statuses (comma separated), waiting on, version |
f.failedState, f.failedStep |
the group: cases whose flow in that state failed at that step (spec 110 R5) |
liveGroupFix=retry |
with a failed-at group: its dry run, Move these cases to a newer version and retry …, is open |
liveCaseTab=work |
with liveCase: the case opens on its Work tab (as Show the incident does) |
liveFix=undo, liveFixRun=<id> |
with liveCase: opens the put-back after Fix and retry once, on that flow, then leaves the address (spec 110 R4) |
Old case links. The old case screen (Parent case · Actual child case · Runtime diagram) is removed (spec 526).
A link that still carries caseContext=1&instance=<id> — a bookmark, a copied link, an older script — opens this view
with that case in the case lens: Studio replaces the address with view=live&liveCase=<id> and drops the old screen's
instance, childInstance, state, runtimeTab, runtimeNode, definition and version. Use liveCase=<id> in
new links and scripts.
The old screen's child-row migration (moving or rolling back one state-flow run on its own) went with it. In Live, move the whole case onto a published version, or use Move to version N and retry for a failed flow; each has its undo.
These are Live's own names: the designer's state parameter selects a state of the draft. Opening the editor from Live leaves all of them behind (the editor only carries livePin, with a group's filters inside it, and the place: view=flow&state=<liveOpen>&node=<liveStep>, or the selected state's or the case's current state's flow, or view=lifecycle&state= for a state with no flow of its own; SCRUM-3314), and Back to Live brings them back. The Design and Live mode tabs carry one thing across: liveState becomes the designer's state, and back (spec 095 FR-047).
Understanding an execution failure
When failure information is available, the failure summary explains the recorded cause in English, the permitted failed location, and the next check. Runtime readers can use this explanation without opening the designer. A person who cannot change the workflow is directed to its owner rather than offered configuration actions. Unknown or legacy causes explicitly say that detailed information is unavailable.
Current failures and recorded history are separate. An older failure can remain in history after recovery; it does not mean the run is still failing. More failures continues the same held history read. Refresh loads current information. A support reference identifies the occurrence; copying evidence excludes raw engine text, credentials, expressions and business values.
Locate appears only when the current view can represent that exact permitted execution and its original model. It inspects the step without resuming, retrying or changing case data. An inaccessible or stale location shows Not available. A missing location action does not grant access to a newer or different run.
Statements about saved case values or completed external actions are shown only when confirmed. An unknown outcome is not permission to retry an external action.
SCRUM-4040 T119/T126 validation update (2026-10-23): the exact case-live route uses existing session-only bootstrap and caller-only workspace metadata, followed by fresh case admission; AppState/store and server policy unchanged. Ordinary figures transport failure now retains previously projected failure summaries with an out-of-date warning; typed authority/scope failures retire them. The root-authenticated native offline/reconnect/reopen control retained its reference/status with zero execution writes and16px warning-to-card spacing. Ten affected consumer suites passed572tests; full suite and runtime-only acceptance remain open. The production build still fails the login startup budget610.3/610.0KB.
When the Operate view cannot establish current access to an opened case, its case content and repair/detail controls are removed. A denied case shows the neutral Not available state. An access-check outage offers Retry, which reads that case again; it does not repeat a repair, migration or workflow action. Case content returns only after a fresh admitted read and verified model resolution. Independently authorized definition overview and analytics remain available. A successful case read whose failure information is unavailable keeps its authorized ordinary content; that diagnostic status does not mean the case recovered or that an uncertain action is safe to repeat.
Canonical feature configuration (spec503)
process.module.enabled and process.tracing.enabled are server startup settings in the canonical file. process.live.case-design is a runtime workspace switch, defaultfalse, with default/global/workspace representations. Changing it does not publish a model or release any held case proof. See Feature switches and migration for exact keys, defaults, scope, direct-edit locking, migration and rollback.