Inflow.aiDocs

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 model-key correction — 8 November 2026. The preserved examples below contain historical camelCase record-type/field keys. Do not copy those keys into the current editor or API: use record type leave_request and the lowercase field keys in the current model worksheet, including request_id, employee_id, manager_id, start_date, end_date, requested_days and decision_comment. Form, rule and case input names are separate declarations; map them explicitly rather than mechanically renaming every input. The preserved body remains historical source material, not a current executable model payload.

Lifecycle authoring and case operations

Learning path: design a case, then its work

Use this guide when a business request has recognizable stages and the work inside a stage needs tasks, decisions or service steps. A lifecycle state is the business stage; its owned BPMN flow describes the work. A human task is an executable step inside that flow. A published form is the captured interface of that task. These objects have related identities, but they are not interchangeable.

The shared example is Leave requests in the synthetic people-ops workspace. Mohammad requests14–18 December 2026; Sara reviews5 requested days; Nadia builds the application. The data tutorial uses model leave, record type leaveRequest and business reference leave-2026-014. Its employeeId and managerId text are business data, not authority to impersonate either person. Select actual User values through admitted identity/assignment controls. Declare case-file startDate/endDate as Date, requestedDays as Number, and any review result/comment with their supported types. A data row does not start a case automatically.

Prepare the authoring worksheet

Item Decide or record before publishing
Lifecycle key A workspace-unique key, for example leave-request; not a generated child key
States One initial working state review; terminal approved and declined states
Owned Review flow Actual human work, a captured published form, explicit assignment and authored completion outcomes
Case-file fields Names, types, required-at-start/default behavior and permitted state outputs
Form identity Actual published key/version and allowed task-submit action; a latest draft is not the pin
Review evidence Saved lifecycle revision, validation issues, compatibility assessment and any explicit consent

Start by drawing the states, then Open flow for Review. Save before Verify/Debug. Configure the task rather than trying to make a state label assign work. Terminal markers without authored flows can finish automatically; an empty initial-to-terminal scaffold is not sufficient business work. Use publication for release and the connected vacation tutorial for the whole journey. The examples are source-backed instructions using synthetic values; they are not newly executed runtime proof.

Worked examples

Example FLOW-LA-01 — Build the Review state around real work

Scenario and inputs. Nadia can author lifecycles in people-ops and has a saved, published decision form available to the Review task. She wants Mohammad’s request to reach Sara, then finish in Approved or Declined. Record the real workspace and selected actor identities; leave-2026-014 is the business reference, not a draft or instance ID.

Procedure. Create the lifecycle with initial Review and two terminal states. Open Review’s owned flow and add a human task named “Review leave request.” Select the published form/version and explicitly choose the manager assignment rule using the admitted User value. Declare approval/comment outputs from the lifecycle case file, wire the task’s authored outcomes to the state outcomes, and connect matching lifecycle transitions. Save, then Verify the saved draft. Read the state/node coordinates of each issue instead of looking only for a green page banner.

Expected result. The draft contains an owned business flow and an explicit route for each declared result. Terminal states need no invented empty human task. The actual saved revision identifies what the next review assesses.

Failure and recovery. If the graph has no real work or a state has no required flow, complete that state before publishing. Do not hide the issue by creating start-to-end scaffolding or posting raw definition XML around the lifecycle service.

Sources. ProcessLifecycleController.java:81; LifecycleModel.java:46; LifecycleState.java:20.

Example FLOW-LA-02 — Commit only declared outputs and authored outcomes

Scenario and inputs. The Review flow captures approved as Boolean and decisionComment as Text. The data record has a separate status enum. Sara’s form declares its own permitted submit actions. Nadia must decide how approved/declined outcomes and record updates relate; completing a task does not automatically rewrite every field of the source record.

Procedure. Declare both case variables and select them as the state’s output contract. In the owned flow, bind allowed form answers to those outputs and configure the end outcomes actually offered by the designer. Match the state transitions to those outcomes. If the business record must change to APPROVED or DECLINED, author the separately admitted rule/record action and its exact publication binding. Save and verify the combined mappings, including the decline branch and optional comment.

Expected result. The compiler can check names, types and outcome routing. The published workflow, rather than a free-text decision in the request body, determines the next state and any permitted record effect.

Failure and recovery. An undeclared target or missing transition is an authoring defect. Correct the saved contract and reassess it; never invent an output name in a task request or assume a display label is a stable outcome key.

Sources. LifecycleState.java:25; ProcessLifecycleController.java:651.

Example FLOW-LA-03 — Reconcile a stale edit without losing another state

Scenario and inputs. Nadia and a second permitted consultant read revision 7 of the same draft. The second editor changes Review’s output mapping and saves revision 8. Nadia’s browser still holds revision 7 and an unrelated label change. The numbers are illustrative; use the actual revision from the draft response.

Procedure. Retain the original body and expected revision. A legacy direct update uses PUT /api/process-lifecycles/{draftId} with name, description, proseText, lifecycle and expectedRevision; a native original-attempt client uses its issued edit intent and the same original command. On conflict, read the authoritative draft again, compare the modified state/output against the local intention, and reapply only the still-intended change to that new snapshot. Save before requesting new publication evidence.

Expected result. The stale update is refused rather than silently overwriting the other editor’s flow. Existing subject binding, other state flows and publication history retain their own values.

Failure and recovery. Do not paste revision 8 into the old revision 7 body. That would disguise an overwrite as concurrency-aware editing. If an original attempt’s reply is uncertain, observe that intent before issuing another edit.

Sources. ProcessLifecycleController.java:114; ProcessLifecycleController.java:903.

Example FLOW-LA-04 — Choose the recipient instead of relying on inspection identity

Scenario and inputs. Mohammad is the actual authenticated case initiator; Sara is the intended manager reviewer. Nadia is the author and may inspect Debug. The record’s text managerId is not itself an ActorRef or a grant. The story must work with ordinary participant rights, not only while Nadia is signed in as an administrator.

Procedure. Inspect the human step’s assignment settings in the owned Review flow. With no authored assignment or explicit assignee, document the existing fallback: the work is offered to the case initiator only when the directory resolves an active eligible person. An absent, inactive or nonhuman initiator can stop the node with an assignment error instead of creating an invisible unassigned task. For manager review, configure the real supported assignee/candidate expression using the correctly selected manager User value and its published inputs. Inspect the task under an admitted test participant and, separately, document the ordinary user’s published task route and required permissions. Capture the assignment source alongside the published form pin.

Expected result. Sara receives or can claim only the work the published assignment policy offers her. Merely selecting Sara on an authoring canvas does not authorize ordinary completion. Mohammad’s starting the case does not automatically mean he is its manager.

Failure and recovery. If the task is offered to Mohammad unexpectedly, fix the authored assignment and review how that change affects existing cases. Do not spoof Sara with a request-body actor, a development header or a Debug participant selection.

Sources. HumanActivityHandler.java:314; TaskController.java:145.

Detailed reference

A lifecycle is the business journey. Its states own BPMN flows; a case is an execution of a published lifecycle version. Generated state-process definitions are internal execution artifacts.

Author the graph, then the work

Open Build → Lifecycles and choose New lifecycle. In the Create lifecycle dialog, name the journey. Define and connect stable state IDs before configuring each state's flow. In Draft, Open flow edits the selected state's BPMN inside its owning lifecycle. In a published release, Open flow inspects that release's saved state flow read-only; choose Open designer from lifecycle detail (or from the lifecycle's row in Build → Lifecycles) or Open draft in the Designer to switch to the current draft. View live, beside it, opens the published lifecycle's Live view; it is disabled, with the reason, until the lifecycle is first published. In the designer the authoring mode is named Design, and one context line in the header says what you edit, what it is based on and whether it is saved ("Editing draft v4 · Based on published v3 · All changes saved"). With a state selected, Case variables above the inspector opens the lifecycle's case file without deselecting the state. The generated parent BPMN is read-only.

In a state flow, drag from a node's visible cardinal dot to the destination dot. The connection starts from the dragged node and ends at the dropped node; the preview and saved line meet the dot centers. A forward connection between offset nodes curves smoothly, while aligned or constrained connections use a clear direct or routed path. The canvas reports invalid destinations, such as a Start event, without adding a flow. Use the port's accessible button and arrow keys to choose a port when connecting by keyboard.

Incomplete drafts can be saved. Publication requires explicit executable BPMN in every nonterminal state. A start/end scaffold does not count as business work, and a lifecycle made only of completion markers cannot be published. Human work requires an explicit task. A terminal state may have no flow and complete automatically, or have authored work that must finish before completion. A terminal state has no outgoing transition.

Build the lifecycle from left to right: hover a state and press + to add the next state already connected to it. + is offered on a terminal state too; using it continues the lifecycle from there, so that state stops being terminal (undo restores it). With a state selected, the toolbox Add state does the same. Transitions are never hidden, however many leave a state. Arrange orders each column so transitions cross as little as possible, and a transition's label sits on its route, clear of the state cards.

The designer lists everything still missing in one place: the issues chip next to the save status (for example "4 issues"). Each issue names the state or transition by its display name and offers Show on canvas or Open flow; the inspector shows only the selected state's issues. Structural gaps (no terminal state, a state with no way out, a branch without a condition) never stop Save — they disable Publish with the reason. Save is refused only for what the server refuses on a draft: outcomes declared on a terminal state, and outcome names that are empty, invalid or repeated.

Service level (spec 124). With no state selected, the inspector's Bindings tab holds the case service level beside the subject: how long a case of this lifecycle should take, and from which share of that an open case is at risk. Turn on Set a service level for every case, then choose Measured in — Business time (only the working hours of a business calendar count; the target is written in working hours or minutes, because a working day depends on the calendar) or Calendar time (around the clock; days allowed) — the target, the calendar (Default calendar follows the workspace's default when the case is read) and At risk after (1 to 99%, default 80). A line under the switch says it in words ("Cases should finish within 40 working hours (Office calendar); at risk after 32 working hours."). A value the server would refuse stays in the section with its message and is not saved; Save and Publish refuse a malformed level (LIFECYCLE_SERVICE_LEVEL_INVALID; the 422 names the field in params.pointer, such as /serviceLevel/target or /serviceLevel/atRiskPercent, for a client that sends the model through the API or MCP; other lifecycle refusals that name a field carry it the same way, for example /variables/2), and Validate and Publish refuse a calendar that is not one of the workspace's (LIFECYCLE_SERVICE_LEVEL_CALENDAR_UNKNOWN). Each published version keeps its own level; Live, Lifecycle data and reports measure every case of that version against it when they are read. Choosing a calendar needs the Process calendar view, Screen manage or Process definition update permission (names only without calendar view). Agents use the commands pd.lifecycle.service-level.set and pd.lifecycle.service-level.clear, or MCP update_lifecycle with serviceLevel (null removes it).

Validate the graph and its owned flows before publishing. Resolve missing states, unreachable states, invalid outcomes, flow errors and incompatible variable/output contracts at their reported state/node locations. Save with the revision last read; a stale revision requires reloading and reconciling changes. Publication also advances the saved overlay revision, so read the current draft again before making the next edit. Validation is not publication authorization or a guarantee that later governance checks will succeed.

Studio Verify checks the saved lifecycle graph and every owned state flow with the same preparation and event-contract validation used by publication. Findings identify their state and node. Saving a new revision invalidates the old report; a response for another revision is not treated as a clean result. Unsaved changes still require saving before verification. An intermediate event retains its selected signal or record kind even while its required fields are blank, so Verify reports the missing signal name, record type or action kind rather than reinterpreting it as a timer. Invalid timer schedules are reported by the authoritative validator and appear in the saved node's readiness findings. Verify does not report UNHANDLED_FAILURE_MODE for the outcome-setter steps the compiler generates inside a state flow; an authored activity that can fail with nothing handling it is still reported, with advice to attach an Error boundary to the activity with the error code left empty and draw its recovery path, or, where the activity has an On failure setting and a failure should not stop the process, to choose Continue with a marker variable.

Verify also names two decision problems that would otherwise only show up when a case stops (SCRUM-4173):

  • Decision can't route (DECISION_READS_UNPROVIDED_VALUE, warning). A decision, or exclusive or inclusive gateway, has no default path, and every one of its conditions reads a value that no form or step in the flow provides. The value is also not required or defaulted at the start, and for a state flow, nothing else in the lifecycle writes it. Unless the value is supplied when the case starts, a case stops at that decision. The finding names the decision and the missing values. Fix it in one of three ways: capture the value in a form or step before the decision, make it required or give it a default at the start, or add a default path. The check is deliberately cautious: it warns only when no branch can be taken while those values are missing. A condition it cannot analyse stays silent, and the general "Missing default flow" warning still applies.
  • Comparison can never work (PROCESS_CONDITION_TYPE_MISMATCH, error, blocks Publish). A gateway condition or transition guard orders a Text value against a Number value (<, <=, >, >= or between) in a position that is always evaluated. Change the variable's type, or compare it with a value of the same type. Text against a date, and mixes the runtime can evaluate, are not reported.

Both appear under Gateway defaults and the condition findings in Studio's Verify view, and choosing a finding opens the decision or transition on the canvas.

Verify → Simulation measures one state's flow against that state flow's own recorded cases (definition key <lifecycleKey>.state.<stateId>). It simulates the flow as the saved draft holds it, compiled the way publication compiles it. The state you were working on is chosen first, and a State flow picker appears when more than one state has a flow. Simulation explains why it is unavailable in each of these cases, and offers the next step where there is one:

  • unsaved changes: "Save to simulate";
  • a lifecycle never published, or a state flow added since the last publish: there are no recorded cases to measure against;
  • no state with a flow;
  • a saved flow that cannot be compiled: the server's reason is shown, with "Try again";
  • a stored draft that has moved on from the version on screen: "Reload process";
  • a state or its flow removed in another tab: "Reload process";
  • not available to you (you may not simulate this lifecycle, or the server refused the run): the neutral "This is not available to you" only, with no "Simulate against history" and no reason; the run is not offered again for that state flow;
  • your access could not be checked right now: "Your access could not be checked right now. Try again shortly.", and "Simulate against history" stays available to try again.

The chosen state flow is kept in the address (?state=). A compile failure offers "Open Findings", which shows where the flow needs fixing.

Existing bindings to independent workflows remain readable with conversion guidance. A reference does not transfer ownership. Replace a legacy binding with explicitly authored state BPMN. Publication requires an unused generated child key and refuses ambiguous or colliding identities; choose a fresh lifecycle key or state ID when necessary. The system does not automatically copy, adopt, delete or overwrite the referenced workflow.

Right-click menu

Right-click anything on the lifecycle canvas or a state's flow canvas to act on it where it is. You can also select it and press Shift+F10 or the Menu key.

Lifecycle canvas

  • State: open its flow, rename it, add the next state, make it initial, mark it terminal (or continue the lifecycle), show its issues, copy, cut, paste, duplicate or delete it.
  • Transition (its line or its label): edit the condition, make it the default ("otherwise"), choose the outcome it routes on, go to its source or target state, or delete it.
  • Empty canvas: add a state where you clicked, paste there, select all, arrange, fit, undo or redo.

Flow canvas

  • Task or event: configure, rename, change the task type, add a connected next element, attach a boundary event, copy the element ID, select similar elements.
  • Move to swimlane ▸ (one element or a selection): choose New horizontal pool, New vertical pool, or any existing lane (listed as "Horizontal · Pool › Lane" / "Vertical · …"). The elements move into that lane in flow order: left to right in a horizontal pool, top to bottom in a vertical one. The pool and lane grow to fit, boundary events go with their activity, and flows between the moved elements are straightened to the pool's direction. It is one undo step.
  • Gateway: set its default path.
  • Sequence flow: edit the condition, make or clear it as the default path, or edit the label.
  • Pool or lane: add, rename or remove lanes.
  • Group: ungroup it.
  • Empty canvas: add an element or paste where you clicked, and show or hide the legend and minimap.

How the menu behaves

  • Selection: right-clicking an item selects it alone. Right-clicking inside a multi-selection keeps the selection and shows the count, and single-item actions say "Select one … to …".
  • Unavailable actions: they stay visible, greyed, with the reason. For example, "This is already the initial state."
  • Published releases: the menu still opens. Viewing actions work (open flow, go to, fit, copy element ID, and copy on the lifecycle canvas); changing actions say the release is read-only. A read-only flow canvas does not copy elements, so its Copy says why.
  • Confirmations: every action does exactly what its toolbar or inspector control does, with the same confirmations: changing a task type, or making a state with outcomes terminal.
  • Fields: text fields, the inspector, the palette and the header keep the browser's own menu.
  • Copy: every Copy action (element ID, keys, URLs) confirms with a short message such as "Element ID copied". It also works when Studio is opened over plain HTTP; if the browser blocks copying, a dialog shows the text selected, ready for Ctrl+C.

Who receives a state's human task

The Lifecycle inspector does not yet let you choose an assignee, group or role for a state's task. When a human task has no assignment, it goes to the default pool: the person who started the case.

  • The task is created unassigned and appears in that person's Tasks → Available to claim. They claim it, it moves to My work, and when they complete it the case moves on.
  • Nobody else is offered the task or may claim it. A process editor can still reassign it.
  • The person who started the case needs task permissions (view and claim) in the workspace. If they do not have them, for example with a designer-only role, an administrator must reassign the task.
  • There is no separation of duties: if the state is an approval, the requester who started the case can approve it. Inflow has no rule that forces a different person to act (owner decision, 2026-10-14). The process author decides who is assigned; to have someone else approve, assign the task to that person, group or role.
  • The person who started the case must be an active person account. If the case was started by the system (a timer, a record trigger or another automatic start), by a service account, or by an account that is now inactive or locked, that step fails with PROCESS_ASSIGNMENT_NO_DEFAULT_POOL. The failure appears as an incident on the case, not as an invisible task. Retrying it fails the same way. To avoid it, start such cases as an active person, or give the task an explicit assignment in its flow and publish a new version.
  • Tasks with an authored assignment, or an explicit assignee, are not affected.
  • In a debug session, the operator who started the session is the default pool. The participant picker for such a task offers only that operator.
  • Tasks created before this change that have no assignee and no candidates stay unassigned. An administrator must reassign them.

Read the selected release

The catalog contains lifecycle parents. Internal state flows and legacy independent processes are not peer business assets. Draft changes are shown separately from the published version.

Lifecycle detail opens the published context when available, otherwise Draft. A published release contains its state graph, authored flow models and exact child definition versions. Draft editing cannot change an existing release. Cases started from these releases keep the stored parent and exact child versions. Older artifacts created before child-version pins retain their existing execution behavior. When a legacy release snapshot is unavailable, the UI shows that limitation rather than substituting the current draft.

Published state-flow links retain the parent, stable state ID and selected version after refresh and browser navigation. The selected release's authored flow remains read-only; a missing release or state is unavailable rather than a substitute current draft. Reach engine artifacts through their owning lifecycle or an authorized diagnostic surface.

Inspect and control cases

Active cases opens distinct parent cases in the selected stable state. The total counts the complete authorized server query, not the loaded page or child tokens. Running/waiting and suspended cases are active; zero and unavailable data have different meanings. Counts and lists span the lifecycle's published versions for that stable state ID; selecting a release for inspection does not filter cases to that version. Counts and lists are separate reads, so transitions between requests can change the count.

Operate resolves the selected case's pinned lifecycle and actual child execution references. A case that completed or moved after opening a list remains inspectable. The context supplies the actual processDefinitionId separately from its key and version for both parent and children. Missing IDs or a missing lifecycle version mean immutable model evidence is unavailable; they must not resolve to a latest model.

Pause uses the existing suspend operation; operator Resume uses activate. Token resume continues a waiting engine token; use task completion for assigned human work. These actions retain permission, confirmation and audit requirements. Parent suspension gates owned execution and new dispatch; already dispatched external effects cannot be recalled. Retained work resumes according to the runtime's durable suspension contract. Pending-arrival deduplication and token guards do not guarantee exactly-once external effects.

API contracts

Use the established authenticated workspace context, including X-Workspace-Id. A workspace query parameter is not an authorization substitute.

Operation Route
Parent catalog GET /api/process-lifecycles
Create lifecycle POST /api/process-lifecycles
Read/update draft GET/PUT /api/process-lifecycles/{draftId}
Validate graph and owned flows POST /api/process-lifecycles/{draftId}/validate
Saved state flow compiled for Verify → Simulate (read-only) GET /api/process-lifecycles/{draftId}/state-flows/{stateId}/candidate
Assess saved parent and owned states POST /api/process-lifecycles/{draftId}/compatibility
Publish reviewed release POST /api/process-lifecycles/{draftId}/publish with expectedRevision
Immutable release GET /api/process-lifecycles/{definitionKey}/versions/{version}
State-scoped cases GET /api/process-instances?processDefinitionKey={key}&lifecycleStateId={stateId}
Pinned case context GET /api/process-operate/instances/{id}/lifecycle-context
Operator pause/resume POST /api/process-instances/{id}/suspend or /activate

Catalog pagination uses page, size and totalItems, with server-side query/status/function filters. The case query accepts activeOnly; the state-scoped default includes RUNNING/SUSPENDED, while an explicit status selects that status. Existing generic instance queries retain their compatibility behavior.

Ordinary raw definition routes cannot create new unowned BPMN, mutate/publish generated children or start them independently. Shared platform services enforce these constraints for Studio, MCP and direct invocation. Trusted lifecycle compilation and subprocess execution remain internal.

State flows inherit their verified owning lifecycle's grants. Editing the parent still requires the relevant global permissions and parent access; parent sharing does not authorize an unrelated lifecycle or bypass explicit denial. These rules also apply when the trusted publisher creates a new state-flow definition.

Who created a lifecycle draft

Every new draft, whether a lifecycle, an imported process, or a state-flow child created by a publish, gets exactly one append-only PROCESS_DEFINITION_CREATED audit event. It is written in the same transaction as the draft. The event's actor is the authenticated creator: the session user, the MCP principal, the importing actor, or the publisher whose publish created a child. A request body can never set it. A creation without a trusted actor is refused before anything is written. A reader holding AUDIT_VIEW reads it through the existing, workspace-scoped audit search:

GET /api/audit-events?entityType=processDefinition&entityId={draftId}&type=PROCESS_DEFINITION_CREATED

  • One event means the creator is recorded.
  • No event means the creator is unknown. Drafts created before SCRUM-4092 have none, and none is ever inferred from a later editor, publisher, receipt or key.
  • The actor is stored as id and type only, with no display name. A reader resolves a current name from the user id.
  • The metadata holds only workspaceId, draftId, definitionKey, businessFunctionKey and the draft's createdAt.
  • Being the recorded creator grants nothing. Access is always decided by current grants.

MCP and Studio Agent

Plan lifecycles[] and use create_lifecycle → update_lifecycle → configure_state_process/configure_task → validate_asset → assess_lifecycle → publish_lifecycle → start_process_instance. Connect states before building their flows. For validate_asset, send assetType: "lifeCycle" and the lifecycle asset key. lifeCycle:{key} identifies the parent asset in build-session state; it is not a tool name. Session publication progress is distinct from the case's business state.

Retired create_process/publish_process calls provide explicit migration guidance. Historical sessions and receipts retain their documented compatibility behavior; no silent wrapping or ownership reassignment occurs. get_build_status records the latest publication per lifecycle: edits and refused publication leave that record intact, while a successful republish replaces it with the new version. Read the immutable release endpoint for an older published version; the build-status array is not a publication-history API. Ring 3 reflects routes and obeys the same authorization and ownership rules. Studio Agent and external MCP consume shared tool implementations and schemas.

Studio Agent keeps POST /api/studio-agent/tools/execute. A named tool uses method: "MCP", path equal to the exact shared tool name, and its argument object in body. Set confirmed: true only after explicit user approval. A model-provided body.confirm is not consent. Unconfirmed execution, including a raw GET, returns HTTP200 with executed: false and inner status: 428; clients must inspect those returned fields. Shared errors and migration guidance remain in the response body.

For engine token resume, use output: {values: {...}}. A nonempty output must contain exactly one values field whose value is an object; flat, mixed, scalar and array shapes are refused with INSTANCES_RESUME_OUTPUT_INVALID before dispatch. Omitted output, null output and an empty object {} retain the existing no-output behavior. Use manage_tasks for normal assigned human work. For signal_instance, the nested signal payload also uses {values:{...}}; invalid shapes are refused before dispatch with INSTANCES_SIGNAL_PAYLOAD_INVALID.

When listing cases with manage_process_instances and operation list_instances, provide the lifecycle parent key. The shared tool classifies an exact key through the authorized diagnostic query GET /api/process-definitions?definitionKey={key}&page=0&size=2; this additive filter uses literal equality and intersects other filters. It does not change the parent-only Lifecycles catalog. Classification requires the existing global definition-view permission and effective object access in the selected workspace. Generated state flows are refused with INSTANCES_GENERATED_CHILD_NOT_LISTABLE. If classification is denied, incomplete, malformed or ambiguous, the tool returns recoverable INSTANCES_CLASSIFICATION_UNAVAILABLE at /payload/processDefinitionKey without issuing a case query. Registered parents, historical lifecycle overlays and verified legacy definitions retain their case-query behavior. Historical LEGACY_PROCESS entries with canonical UNRESOLVED ownership and PROCESS_OWNERSHIP_UNRESOLVED diagnostics also retain authorized read-only case inspection. That diagnostic does not certify independence or grant start, sharing, mutation or adoption rights. No visible exact match proceeds to the existing runtime query, which retains its own authorization and unknown-key behavior.

Studio Agent build state uses a server-generated logical identifier inside the authenticated HTTP session. Security-driven cookie ID rotation preserves the blueprint; a new or invalidated session does not recover the old blueprint. Actor and workspace partitions still apply.

See the MCP design and journeys for exact tool payloads, confirmation requirements and repair receipts.

Further contracts: publication, state Debug, case runtime, MCP journeys.

Revision-bound publication and explicit state rebind

Compatibility is a pure assessment of the saved lifecycle overlay. Its response contains draftId, definitionKey, revision, the existing compatibility DTO under parent, and stateFlows: [{stateId, definitionKey, assessment}]. Each nested assessment preserves level, requiresAcknowledgement, breaking, additive, nodeRebindReport, and impactPreview. The aggregate requiresAcknowledgement is the OR of the parent and state assessments. A task is qualified by stateId and nodeId; different states may use the same nodeId. Assessment neither creates child drafts nor consumes versions, and parent compatibility uses prospective child pins.

Publish accepts {releaseNotes, acknowledgeBreakingChange, expectedRevision}. The actor comes from the authenticated server context. Send the exact revision assessed and reviewed. Missing revision, including a null or absent body, fails with HTTP 428 LIFECYCLE_REVISION_REQUIRED; stale consent fails with HTTP 409 PROCESS_LIFECYCLE_CONFLICT. The overlay is locked and checked inside the publication transaction before child writes; final revision CAS and rollback remain in force. Existing raw process publication contracts are unchanged.

A rebind is an explicit edit of the owning state's saved flow. After saving, reassess that new revision before publishing. Never substitute a latest revision for reviewed consent. A changed assessment must be reviewed again. assess_lifecycle({lifecycleKey}) exposes this same aggregate through the shared MCP/Studio Agent tool registry. publish_lifecycle requires expectedRevision and compares a fresh assessment before forwarding that same value. When acknowledgement is needed, or explicitly supplied, MCP also requires confirm: true and nonblank release notes. Clean publication without acknowledgement remains supported. The canonical shared registry now contains 46 tools.

Try “document generation”, “integrations” or “first form”.