@uipath/skills 1.195.0

package/skills/uipath-maestro-bpmn/references/author/references/supported-elements.md

@@ -0,0 +1,123 @@
+# Supported Elements
+
+Use this supported coverage map before choosing a BPMN wrapper or UiPath extension type. Treat anything outside this map, or listed in [Current generation exclusions](#current-generation-exclusions), as preserve-only unless a newer product contract says otherwise.
+
+## Modeling rule
+
+Pick the BPMN element first, then pick the UiPath execution recipe.
+
+- RPA workflows, agents, API workflows, and most async external executions are `bpmn:serviceTask`.
+- Queue item creation is `bpmn:sendTask`; create-and-wait queue work is `bpmn:serviceTask`.
+- Business rules are `bpmn:businessRuleTask`.
+- HITL is `bpmn:userTask`.
+- Agentic process and case-management process calls are `bpmn:callActivity`.
+- Integration Service waits are `bpmn:receiveTask` or event wrappers, and their executable metadata is CLI-owned.
+- Script work is `bpmn:scriptTask`; it is not a generic service task.
+
+## Standard BPMN coverage
+
+The model may author these standard BPMN structures when the process intent is clear and every visible element has BPMN DI.
+
+| Family | Supported elements |
+| --- | --- |
+| Events | `bpmn:startEvent`, `bpmn:endEvent`, `bpmn:intermediateCatchEvent`, `bpmn:intermediateThrowEvent`, `bpmn:boundaryEvent` |
+| Event definitions | none, message, timer, error, and terminate end events where valid for that event kind |
+| Gateways | `bpmn:exclusiveGateway`, `bpmn:inclusiveGateway`, `bpmn:parallelGateway`, `bpmn:eventBasedGateway` |
+| Tasks | `bpmn:task`, `bpmn:serviceTask`, `bpmn:sendTask`, `bpmn:receiveTask`, `bpmn:userTask`, `bpmn:businessRuleTask`, `bpmn:scriptTask` |
+| Containers | `bpmn:subProcess`, event subprocess when the start event type is supported, `bpmn:callActivity` |
+| Flow | `bpmn:sequenceFlow` with source, target, optional condition, optional default references on gateways |
+| Definitions and visual context | `bpmn:message`, `bpmn:error`, item definitions, data objects, data stores, text annotations, groups, pools, and lanes when required by the model |
+
+Visual-only elements such as pools, lanes, data objects, data stores, text annotations, and groups can describe the model but do not execute. Do not use them as substitutes for executable variables, mappings, or task payloads.
+
+## Current generation exclusions
+
+Do not generate these BPMN structures in new Maestro BPMN source. If they appear
+in imported or brownfield files, preserve them and report that the skill cannot
+safely regenerate or normalize them unless a current product contract and local
+CLI validation prove support.
+
+Planned, future, preview, and TBD support statuses are treated as unsupported
+for generation until they are confirmed by current tooling.
+
+| Family | Excluded from new generation |
+| --- | --- |
+| Gateways | `bpmn:complexGateway` |
+| Tasks and containers | `bpmn:manualTask`, `bpmn:adHocSubProcess`, `bpmn:transaction` |
+| Event definitions | `bpmn:conditionalEventDefinition`, `bpmn:signalEventDefinition`, `bpmn:escalationEventDefinition`, `bpmn:compensateEventDefinition`, `bpmn:cancelEventDefinition`, `bpmn:linkEventDefinition`, multiple event definitions, and parallel multiple event definitions |
+| Markers | Standard loop markers and compensation markers. Use only documented multi-instance parallel or sequential metadata for new loops. |
+
+Terminate is supported only for end events. Do not generate terminate starts,
+boundary events, intermediate catches, or intermediate throws.
+
+## UiPath extension coverage
+
+Use lower-case XML tags in authored examples: `uipath:activity`, `uipath:event`, and `uipath:mapping`.
+For copyable canonical shells, including the required nested
+`uipath:type value="..."` element, see
+[../../shared/wrapper-shells.md](../../shared/wrapper-shells.md). Do not use legacy
+`<uipath:activity type="...">` shorthand in new XML.
+For resource-backed tasks, `uipath:activity` identifies the wrapper type and
+resource context; task payload inputs and outputs belong in sibling
+`uipath:mapping version="v1"` elements.
+
+| Extension type | BPMN wrapper | XML tag | Ownership |
+| --- | --- | --- | --- |
+| `BPMN.Variables` | `bpmn:task` | `uipath:mapping` | Model-owned |
+| `BPMN.ScriptTask` | `bpmn:scriptTask` | `uipath:mapping` plus `uipath:scriptVersion` | Model-owned; parser executes as `Scp.Script` |
+| `Actions.HITL` | `bpmn:userTask` | `uipath:activity` | Model may draft shell; resource/form binding resolved by CLI or operator |
+| `Orchestrator.StartJob` | `bpmn:serviceTask` | `uipath:activity` | Model may draft shell; resource binding and schemas resolved by CLI or operator |
+| `Orchestrator.StartAgentJob` | `bpmn:serviceTask` | `uipath:activity` | Model may draft shell; agent binding and schemas resolved by CLI or operator |
+| `A2A.AgentExecution` | `bpmn:serviceTask` | `uipath:activity` | Model may draft shell; agent metadata resolved by CLI or operator |
+| `Orchestrator.ExecuteApiWorkflowAsync` | `bpmn:serviceTask` | `uipath:activity` | Model may draft shell; API workflow binding and schemas resolved by CLI or operator |
+| `Orchestrator.CreateQueueItem` | `bpmn:sendTask` | `uipath:activity` | Model may draft shell; queue binding resolved by CLI or operator |
+| `Orchestrator.CreateAndWaitForQueueItem` | `bpmn:serviceTask` | `uipath:activity` | Model may draft shell; queue binding and callback behavior resolved by CLI or operator |
+| `Orchestrator.BusinessRules` | `bpmn:businessRuleTask` | `uipath:activity` | Model may draft shell; rule binding and schemas resolved by CLI or operator |
+| `Orchestrator.StartAgenticProcess` | `bpmn:callActivity` | `uipath:activity` | Model may draft shell; called process binding resolved by CLI or operator |
+| `Orchestrator.StartAgenticProcessAsync` | `bpmn:callActivity` | `uipath:activity` | Model may draft shell; called process binding resolved by CLI or operator |
+| `Orchestrator.StartCaseMgmtProcess` | `bpmn:callActivity` | `uipath:activity` | Preserve or draft only with a dedicated case-management contract |
+| `Orchestrator.StartCaseMgmtProcessAsync` | `bpmn:callActivity` | `uipath:activity` | Preserve or draft only with a dedicated case-management contract |
+| `Maestro.ReceiveMessageEvent` | start, intermediate catch, or boundary message event | `uipath:event` | Model-owned when message name and public-safe payload contract are known |
+| `Maestro.SendMessageEvent` | intermediate throw or end message event | `uipath:event` | Model-owned when message name and public-safe payload contract are known |
+| `Maestro.CasePlanScheduler` | `bpmn:serviceTask` | `uipath:activity` | Preserve or draft only with a dedicated case-management contract |
+| `Maestro.CaseManagerGuardrails` | `bpmn:serviceTask` | `uipath:activity` | Preserve-only until documented |
+| `Maestro.CaseRulesEvaluator` | `bpmn:serviceTask` | `uipath:activity` | Preserve-only until documented |
+| `Intsvc.ActivityExecution` | `bpmn:sendTask` and supported event wrappers | `uipath:activity` | CLI-owned enrichment |
+| `Intsvc.HttpExecution` | `bpmn:sendTask` or intermediate throw | `uipath:activity` | After skeleton confirmation, request-and-continue plain connectionless HTTP may use [http-request.md](task-recipes/http-request.md); connector-authenticated or dynamic HTTP remains CLI-owned enrichment |
+| `Intsvc.UnifiedHttpRequest` | `bpmn:sendTask` or intermediate throw | `uipath:activity` | CLI-owned enrichment |
+| `Intsvc.AsyncExecution` | `bpmn:serviceTask` | `uipath:activity` | CLI-owned enrichment |
+| `Intsvc.SyncAgentExecution` | `bpmn:serviceTask` | `uipath:activity` | CLI-owned enrichment |
+| `Intsvc.AsyncAgentExecution` | `bpmn:serviceTask` | `uipath:activity` | CLI-owned enrichment |
+| `Intsvc.SyncWorkflowExecution` | `bpmn:serviceTask` | `uipath:activity` | CLI-owned enrichment |
+| `Intsvc.AsyncWorkflowExecution` | `bpmn:serviceTask` | `uipath:activity` | CLI-owned enrichment |
+| `Intsvc.EventTrigger` | message start event | `uipath:event` | CLI-owned enrichment |
+| `Intsvc.TimerTrigger` | timer start event | `uipath:activity` | CLI-owned enrichment |
+| `Intsvc.WaitForEvent` | `bpmn:receiveTask`, intermediate catch, or boundary message event | `uipath:event` | CLI-owned enrichment |
+
+## Script task runtime
+
+Script tasks execute JavaScript through Jint, not Node.js or a browser runtime.
+
+- Use `bpmn:scriptTask scriptFormat="JavaScript"`.
+- Put source in `bpmn:script` CDATA and include `uipath:scriptVersion`; prefer `v3`.
+- Inputs are exposed as named JavaScript variables after Maestro maps inputs into an `args` JSON body.
+- Available helpers are limited to `uipath.aggregate`, `uipath._aggregate`, `uipath._pipe`, and a no-op `console`.
+- There is a 64 MB memory limit and a 30 second execution timeout.
+- Do not use packages, filesystem, network, browser globals, or long-running async behavior.
+- For version `v2` and later the script may return any JSON value under `response`; older versions must return a JSON object.
+
+## Integration Service boundary
+
+For `Intsvc.*` elements, the model may author the surrounding BPMN shell,
+variables, mappings, error paths, diagram geometry, and a non-executable draft
+`uipath:type value="Intsvc.<Variant>"` shell with placeholder strings. The
+documented pass-2 exception is confirmed plain connectionless HTTP, which must
+follow [http-request.md](task-recipes/http-request.md). Connector-backed or
+dynamically schematized `Intsvc.*` work still requires the CLI to enrich connector key,
+operation/event metadata, connection binding, trigger property bindings,
+schemas, generated outputs, `bindings_v2.json`, and package metadata before
+upload or run.
+
+## Preservation boundary
+
+If an imported file contains extension types not listed here, preserve them and report that the skill cannot safely regenerate them. Do not delete unknown extensions unless the user explicitly asks for normalization.

package/skills/uipath-maestro-bpmn/references/author/references/task-recipes/README.md

@@ -0,0 +1,29 @@
+# Task Recipes
+
+Use these recipes after the BPMN skeleton is chosen. They describe how confirmed
+UiPath resource-backed work maps onto standard BPMN task classes during pass 2.
+Individual recipe files assume the pass-1 model is already selected; they are
+not process-modeling guidance.
+
+> Copyable minimal XML shell per wrapper: [../../../shared/wrapper-shells.md](../../../shared/wrapper-shells.md). Each recipe below describes when to use it and what fields are model- versus CLI-owned; copy the matching shell from `wrapper-shells.md` for the exact XML.
+
+| Need | BPMN element | Recipe |
+| --- | --- | --- |
+| Start an RPA process | `bpmn:serviceTask` | [rpa-job.md](rpa-job.md) |
+| Start a UiPath agent or A2A agent | `bpmn:serviceTask` | [agent-job.md](agent-job.md) |
+| Execute an API workflow | `bpmn:serviceTask` | [api-workflow.md](api-workflow.md) |
+| Implement confirmed request-and-continue plain HTTP | `bpmn:sendTask` | [http-request.md](http-request.md) |
+| Create a queue item | `bpmn:sendTask` | [queue.md](queue.md) |
+| Create and wait for a queue item | `bpmn:serviceTask` | [queue.md](queue.md) |
+| Execute a business rule | `bpmn:businessRuleTask` | [business-rule.md](business-rule.md) |
+| Create an Action Center human task | `bpmn:userTask` | [hitl.md](hitl.md) |
+| Call an agentic or case-management process | `bpmn:callActivity` | [call-activity.md](call-activity.md) |
+
+Rules:
+
+- Do not create Flow-style peer nodes in BPMN. Keep the BPMN element class visible in the XML.
+- Pass 1 still owns process modeling. Apply these recipes only after the BPMN
+  skeleton is chosen and the resource-backed node is ready for implementation.
+- Resource identity, folder binding, and dynamic schemas are resolved by CLI/operator unless this skill has a documented public-safe shell contract.
+- Keep resource names synthetic or placeholder-safe in examples.
+- Put routing logic on sequence flows and gateways after the task, not inside the resource recipe.

package/skills/uipath-maestro-bpmn/references/author/references/task-recipes/agent-job.md

@@ -0,0 +1,36 @@
+# Agent Job Recipe
+
+Agent wrappers are authored as `bpmn:serviceTask`, but the executable runtime
+contract depends on the process type reported by
+`uip or processes list --all-fields`, not the source project label. Some coded
+Python "agents" are published as `processType: "Function"` and are not the same
+runtime contract as low-code Agent Builder processes published as
+`processType: "Agent"`.
+
+| Agent deployment style | Wrapper shell | Notes |
+| --- | --- | --- |
+| Coded Python dependency published as `Function` | Use the process wrapper contract, not `StartAgentJob`, unless discovery documents a different wrapper | Resolve process identity, folder scope, input schema, and output schema before Operate. |
+| Low-code Agent Builder agent published as `Agent` | `Orchestrator.StartAgentJob` shell | Use resolved process identity fields, generated bindings, and current input/output schema metadata. Do not claim executable success from local XML validation alone. |
+| External A2A agent addressed by URL / skillId / authToken | `A2A.AgentExecution` | Studio Web renders this as an external A2A node and disables the Action dropdown. Do not use for folder-deployed agents — the canvas will treat the task as misconfigured. |
+| Integration Service external agent | `Intsvc.SyncAgentExecution`, `Intsvc.AsyncAgentExecution`, or legacy `Intsvc.AsyncExecution` | CLI must enrich connector resource key, connection binding, dynamic schemas, and operation metadata. |
+
+Common authoring mistake: assuming local validation or packaging proves the
+agent wrapper is executable. Validation checks structure and package shape; an
+authorized target-environment run is needed before claiming runtime behavior.
+Put the `JobArguments` input payload and `Process response` output payload as
+direct children of `uipath:activity`; do not put them in a sibling
+`uipath:mapping`.
+
+The model may draft:
+
+- Service task wrapper, variables, mappings, timeout/error paths, and validation gateways.
+- Public-safe prompt/input and output variable names.
+- A documented non-Integration-Service shell when resource metadata is known.
+
+CLI or operator must resolve:
+
+- Agent identity, version, folder binding, and generated resources.
+- Dynamic input and output schemas.
+- External-agent connector metadata for `Intsvc.*` variants.
+
+Add HITL review when agent output drives high-impact decisions or irreversible actions.

package/skills/uipath-maestro-bpmn/references/author/references/task-recipes/api-workflow.md

@@ -0,0 +1,29 @@
+# API Workflow Recipe
+
+The current supported implementation wrapper for confirmed API workflow
+invocation is `bpmn:serviceTask` with `Orchestrator.ExecuteApiWorkflowAsync`.
+
+Use these context fields:
+
+- `ReleaseKey` = Orchestrator process GUID from `uip or processes list`.
+- `FolderKey` = target folder GUID.
+- `FolderPath` = target folder path.
+- `Name` = process display name.
+
+Use `type="string"` on those context inputs. Do not rely on a lone display
+name when the wrapper requires resolved process and folder identity.
+
+The model may draft:
+
+- Service task wrapper and BPMN DI.
+- Request variables, response variables, status/error variables, and mappings.
+- Public-safe request body examples and boundary error paths.
+
+CLI or operator must resolve:
+
+- API workflow resource identity, folder binding, and generated package resources.
+- Solution-style `bindings_v2.json` entries for `uip solution resource refresh`.
+- Dynamic request and response schemas.
+- Fire-and-forget versus wait behavior when the product contract exposes that choice.
+
+Stop before Operate when workflow binding, schema, or wait behavior is unresolved.

package/skills/uipath-maestro-bpmn/references/author/references/task-recipes/business-rule.md

@@ -0,0 +1,18 @@
+# Business Rule Recipe
+
+The current supported implementation wrapper for confirmed business rule
+execution is `bpmn:businessRuleTask` with `Orchestrator.BusinessRules`.
+
+The model may draft:
+
+- Business rule task wrapper, incoming/outgoing flows, and BPMN DI.
+- Fact variables, result variables, diagnostics variables, and mappings.
+- A gateway after the rule task when rule output drives routing.
+- Retry, boundary error, or manual review paths when failures are recoverable.
+
+CLI or operator must resolve:
+
+- Rule identity, version, folder binding, and generated binding resources.
+- Dynamic input and output schemas.
+
+Do not represent a business rule as a generic service task in new XML unless preserving an imported file or matching an explicit product migration contract.

package/skills/uipath-maestro-bpmn/references/author/references/task-recipes/call-activity.md

@@ -0,0 +1,56 @@
+# Call Activity Recipe
+
+The current supported implementation wrapper for confirmed process calls
+exposed through Orchestrator process-orchestration resource types is
+`bpmn:callActivity`.
+
+Supported shells:
+
+- `Orchestrator.StartAgenticProcess`
+- `Orchestrator.StartAgenticProcessAsync`
+- `Orchestrator.StartCaseMgmtProcess`
+- `Orchestrator.StartCaseMgmtProcessAsync`
+
+The model may draft:
+
+- Call activity wrapper, mappings, boundary events, and BPMN DI.
+- Placeholder-safe called-resource intent when a documented contract exists.
+- Synchronous versus asynchronous routing as explicit process behavior.
+
+CLI or operator must resolve:
+
+- Called process identity, package/resource binding, and generated package metadata.
+- Dynamic input/output schemas.
+- Case-management details unless a dedicated case-management contract is available.
+
+Use subprocesses for inline local process structure. Use call activities when execution leaves the local BPMN scope.
+
+## Mapping shape
+
+Use normal activity mapping rules:
+
+- Inputs read declared process variables with `=vars.<variableId>`.
+- Outputs target declared `uipath:inputOutput` or `uipath:output` variable ids.
+- Boundary errors, retries, and error mappings use
+  [error-handling.md](../../../shared/error-handling.md).
+- If the called resource contract is unknown, leave the call activity as draft
+  intent instead of guessing input/output schemas.
+
+Minimal draft shell:
+
+```xml
+<bpmn:callActivity id="Call_ReviewProcess" name="Call Review Process">
+  <bpmn:extensionElements>
+    <uipath:activity version="v1">
+      <uipath:type value="Orchestrator.StartAgenticProcess" version="v1" />
+      <uipath:context>
+        <uipath:input name="process" type="resource" value="=bindings.Binding_ReviewProcess" />
+      </uipath:context>
+      <uipath:input name="payload" type="json" target="bodyField"><![CDATA[
+        {"requestId":"=vars.Var_RequestId"}
+      ]]></uipath:input>
+      <uipath:output name="status" type="string" var="Var_CallStatus" source="status" />
+    </uipath:activity>
+  </bpmn:extensionElements>
+</bpmn:callActivity>
+```

package/skills/uipath-maestro-bpmn/references/author/references/task-recipes/hitl.md

@@ -0,0 +1,17 @@
+# HITL Recipe
+
+The current supported implementation wrapper for confirmed Action Center human
+work is `bpmn:userTask` with `Actions.HITL`.
+
+The model may draft:
+
+- User task wrapper, variable mappings, boundary timer/error paths, and post-task gateways.
+- Public-safe form field names, outcome variable names, and decision routes.
+- Placeholder-safe assignment or routing intent when the user explicitly provides it.
+
+CLI or operator must resolve:
+
+- Real Action Center app/form, folder, queue, group, user, and notification metadata.
+- Dynamic form schemas and generated resources.
+
+No personal names, email addresses, tenant URLs, or exported form payloads should appear in authored examples.

package/skills/uipath-maestro-bpmn/references/author/references/task-recipes/http-request.md

@@ -0,0 +1,119 @@
+# HTTP Request Recipe
+
+Use this recipe for a confirmed plain HTTP request where the workflow owns the URL,
+method, payload, and response parsing. Do not use it for connector-authenticated
+operations, Integration Service connector objects, dynamic connector schemas, or
+tenant-specific connection resources; those remain CLI-enriched Integration
+Service work.
+
+## Modeling boundary
+
+Choose the BPMN element for the skeleton before choosing this implementation
+recipe. For confirmed request-and-continue HTTP work, the current supported
+implementation wrapper is `bpmn:sendTask` with `Intsvc.HttpExecution`. If the
+skeleton uses a different supported BPMN shape for a clear modeling reason, do
+not rewrite the topology just to use this recipe.
+
+Do not represent an executable HTTP call as:
+
+- A blank `bpmn:task` or unlabeled placeholder after pass 2 is expected to be
+  executable.
+- A script task that performs network I/O.
+- A connector activity with guessed metadata or copied tenant values.
+
+If the executable HTTP activity shape is unavailable in the current tooling,
+keep the node as draft intent and report it as not implemented.
+
+## HTTP shape decision
+
+| Scenario | Authoring decision |
+| --- | --- |
+| Plain connectionless request and the workflow owns URL, method, payload, and parsing | Use this `Intsvc.HttpExecution` recipe after skeleton confirmation. |
+| Connector-authenticated request, tenant connection, dynamic connector schema, or object operation | Keep the BPMN node as draft intent and hand enrichment to the CLI. |
+| Solution/V2 unified HTTP shape is explicitly available from current tooling | Let CLI enrichment generate `Intsvc.UnifiedHttpRequest`; do not copy this recipe by hand. |
+| Unsure which HTTP runtime is active | Keep draft intent and report the missing enrichment decision. |
+
+## Executable contract
+
+For confirmed connectionless HTTP execution, use the current UiPath HTTP
+activity shape rather than a generic connector guess:
+
+- `uipath:type` service type: `Intsvc.HttpExecution`.
+- Request fields are explicit runtime inputs: `mode`, `method`, `url`,
+  `headers`, `parameters`, and `body`.
+- JSON fields use CDATA and valid JSON objects; use `{}` when no headers,
+  parameters, or body are required.
+- Output maps the activity `response` to a declared JSON variable with
+  `source="=response"`.
+- Downstream script or mapping steps consume that response variable and write
+  typed process variables for business decisions.
+
+Declare variables for:
+
+- Configurable request inputs when the caller should control them.
+- Raw HTTP response, including status code and body.
+- Parsed fields that downstream gateways, scripts, or outputs need.
+- Final user-facing result variables.
+
+## Generic XML shape
+
+Use this shape for plain connectionless HTTP. Keep IDs, names, URL, method,
+and target variables specific to the workflow; keep the field set intact.
+
+```xml
+<uipath:inputOutput id="Var_HttpResponse" name="httpResponse" type="jsonSchema"><![CDATA[
+{"type":"object"}
+]]></uipath:inputOutput>
+
+<bpmn:sendTask id="Task_CallHttpEndpoint" name="Call HTTP endpoint">
+  <bpmn:extensionElements>
+    <uipath:activity version="v1">
+      <uipath:type value="Intsvc.HttpExecution" version="v1" />
+      <uipath:context>
+        <uipath:input name="mode" type="string" value="manual" />
+        <uipath:input name="method" type="string" value="GET" />
+        <uipath:input name="url" type="string" value="https://example.invalid/resource" />
+        <uipath:input name="headers" type="json"><![CDATA[{}]]></uipath:input>
+        <uipath:input name="parameters" type="json"><![CDATA[{}]]></uipath:input>
+        <uipath:input name="body" type="json"><![CDATA[{}]]></uipath:input>
+      </uipath:context>
+      <uipath:output name="response" type="json" source="=response" var="Var_HttpResponse" />
+    </uipath:activity>
+  </bpmn:extensionElements>
+  <bpmn:incoming>Flow_Previous_CallHttpEndpoint</bpmn:incoming>
+  <bpmn:outgoing>Flow_CallHttpEndpoint_Next</bpmn:outgoing>
+</bpmn:sendTask>
+```
+
+For `POST`, `PUT`, or `PATCH`, keep `headers`, `parameters`, and `body`
+present. Put JSON request payloads in `body` CDATA and parse the raw response
+in a downstream script task rather than embedding business logic in the HTTP
+activity.
+
+## Verification
+
+Local validation is necessary but not enough to call HTTP work implemented.
+Before reporting an HTTP node as executable, verify one of:
+
+- CLI/Studio Web enrichment generated the HTTP activity metadata.
+- A debug/run instance shows the HTTP element received request inputs and
+  produced the mapped response variable.
+
+When a run is available, inspect instance variables and confirm:
+
+- The HTTP task output includes status and response body.
+- Parse steps read the raw response variable and produce non-placeholder
+  business variables.
+- Final outputs reflect parsed runtime data, not canned text.
+
+## Status language
+
+Use precise status in summaries:
+
+- **Executable** - request activity, input fields, output variable, and
+  downstream mappings are present; runtime variable evidence is available if a
+  run was performed.
+- **Draft** - BPMN shape and intent are present, but executable HTTP metadata is
+  missing or awaiting enrichment.
+- **Mock** - the process returns fixed sample data instead of calling HTTP.
+- **Blocked** - required URL, auth, schema, or enrichment decision is missing.

package/skills/uipath-maestro-bpmn/references/author/references/task-recipes/queue.md

@@ -0,0 +1,21 @@
+# Queue Recipe
+
+Use the BPMN wrapper that matches the confirmed queue behavior.
+
+| Operation | BPMN element | Extension type |
+| --- | --- | --- |
+| Create queue item and continue | `bpmn:sendTask` | `Orchestrator.CreateQueueItem` |
+| Create queue item and wait for completion | `bpmn:serviceTask` | `Orchestrator.CreateAndWaitForQueueItem` |
+
+The model may draft:
+
+- Queue task wrapper, variables, payload mappings, outputs, and BPMN DI.
+- Public-safe payload fields, reference, priority, deadline, and transaction metadata.
+- Duplicate-reference and unavailable-queue error paths.
+
+CLI or operator must resolve:
+
+- Queue identity, folder binding, generated package resources, and any downstream callback contract.
+- Tenant-specific queue names, queue IDs, and folder keys.
+
+Do not model downstream processing implicitly. Add an explicit wait, callback, or follow-up task when the process needs a completion result.

package/skills/uipath-maestro-bpmn/references/author/references/task-recipes/rpa-job.md

@@ -0,0 +1,23 @@
+# RPA Job Recipe
+
+The current supported implementation wrapper for confirmed RPA process
+execution is `bpmn:serviceTask` with `Orchestrator.StartJob`.
+
+Use a complete `StartJob` context: process key, folder key, folder ID, folder
+path, and process name. Resolve these values from process and folder discovery
+before execution; keep examples public-safe.
+
+The model may draft:
+
+- Stable service task ID, display name, incoming/outgoing flows, and BPMN DI.
+- Root variables for process inputs, job status, output arguments, and errors.
+- Public-safe `uipath:activity` shell only when the required context/input/output contract is known.
+- Boundary error or timeout paths and post-job gateways.
+
+CLI or operator must resolve:
+
+- Real process identity, release/folder binding, robot/runtime scope, and generated binding resources.
+- Input/output argument schemas.
+- Whether the task waits for completion or only starts the job.
+
+Stop before Operate if process binding, folder scope, argument schema, or wait semantics are unresolved.

package/skills/uipath-maestro-bpmn/references/author/references/validation.md

@@ -0,0 +1,118 @@
+# Validation
+
+Run validation after the local BPMN edit is coherent. Do not chase every intermediate invalid state while creating nodes and flows.
+
+## Local checks
+
+Validate these before Operate:
+
+- The pass 1 skeleton has been confirmed or the edit is small and explicitly summarized.
+- New source does not generate any structure listed in
+  [Current generation exclusions](supported-elements.md#current-generation-exclusions).
+- A pass 1 skeleton uses business-readable conditions rather than runtime
+  `=vars.<variableId>` expressions for variables that do not exist until pass 2.
+- BPMN XML parses with the UiPath extension descriptor.
+- At least one valid diagram and plane exists.
+- Diagram plane references an existing root process, collaboration, or subprocess.
+- Every rendered node has a shape and every rendered edge has waypoints.
+- Root variables, bindings, migration metadata, and UiPath transaction-root
+  markers are structurally valid.
+- New root variables use `uipath:input`, `uipath:inputOutput`, or
+  `uipath:output`; generic `uipath:variable direction="..."` appears only when
+  preserving imported XML.
+- Entry point IDs are unique and appear on root-level start events.
+- Entry point input variables use an `elementId` matching the start event.
+- Binding expressions in context values resolve to root bindings.
+- Required context/input fields are present for documented service types.
+- Sequence flows connect legal source and target types.
+- Message flows do not connect elements inside the same pool.
+- Message event definitions reference declared `bpmn:message` elements.
+- Gateway splits have valid conditions/defaults.
+- Each scope has at most one blank start event.
+- Event subprocesses have exactly one start event.
+- Boundary error events and error event subprocesses reference valid error definitions.
+- Boundary events own their exception outgoing flows; attached activities do
+  not list boundary exception flows as normal incoming/outgoing flows.
+- Multi-instance collection bindings reference declared variables, subprocess item access uses the documented iterator shape, and sequential/parallel metadata is explicit.
+- Expressions avoid assignment operators in fields that require read-only expression evaluation.
+- Runtime expressions use `vars.<variableId>`, `bindings.<bindingId>`, `result`,
+  or the documented iterator/error namespaces instead of bare variable names.
+- Output mappings target declared mutable variables.
+- Retry and error mapping metadata use current attributes from
+  [shared/error-handling.md](../../shared/error-handling.md).
+- CLI-owned Integration Service fields have been enriched or are clearly marked as blockers.
+
+For local-only authoring, always execute at least one validation command before
+packaging. The current local CLI validator expects a BPMN/XML file path, so use
+the main source file:
+
+```bash
+uip maestro bpmn validate ProjectName/ProjectName.bpmn --output json
+```
+
+Only validate a project directory if the installed CLI explicitly supports that
+shape. If the installed CLI does not expose validation, run an explicit XML
+parse command against the BPMN source, for example:
+
+```bash
+python3 -c "import xml.etree.ElementTree as ET; ET.parse('ProjectName/ProjectName.bpmn')"
+```
+
+Do not treat reading the file or visually inspecting generated metadata as a
+validation step; the validation command must run and succeed before `pack`.
+
+## Package checks
+
+Before executing `uip maestro bpmn pack`, ensure the project directory contains
+`project.uiproj`, `operate.json`, `entry-points.json`, `bindings_v2.json`, and
+`package-descriptor.json`. If any generated file is missing, regenerate it or
+write the placeholder-safe local-only shape from
+[shared/local-metadata-regeneration-guide.md](../../shared/local-metadata-regeneration-guide.md)
+before packing.
+
+### Validator coverage across CLI surfaces
+
+`uip maestro bpmn pack` and `uip solution pack` share the same BPMN validation
+rules. A BPMN that passes one will hit the same diagnostics under the other on
+the packager-level rules (binding-backed `Orchestrator.StartAgentJob` context
+inputs, contract placement, declared variables, expression scoping, and the
+rest). Do not assume one CLI surface is "less strict" than the other.
+
+The Studio Web Health Analyzer runs a separate canvas-side rule set and can
+surface issues that neither CLI command catches (or vice versa). Treat Health
+Analyzer as a third signal, not a duplicate. When a real run surfaces a
+diagnostic that the CLI did not flag, report it as a packager-validator gap so
+the rule reaches every caller.
+
+When generated package files exist, verify that:
+
+- `bindings_v2.json` matches root bindings and enriched resource metadata.
+- `entry-points.json` matches root start events, entry point IDs, and variable schemas.
+- `operate.json` points at the intended main BPMN file and content type.
+- `package-descriptor.json` includes the BPMN and generated JSON files under content.
+
+Use [shared/local-metadata-regeneration-guide.md](../../shared/local-metadata-regeneration-guide.md) when a mismatch requires local regeneration or Integration Service enrichment.
+
+## Result handling
+
+- Blocking errors must be fixed before upload, publish, debug, or run.
+- Warnings may be acceptable for local drafts, but warnings about CLI-owned executable elements are blockers for real runs.
+- If validation tooling is missing, report the exact checks that could not run and keep the project in Author state.
+- If Integration Service enrichment is unavailable, validation can pass only for source shape review; do not report the project as ready for Operate.
+
+## Implementation status summary
+
+When handing off to Operate or reporting completion, classify each external,
+resource-backed, HTTP, human, child-process, or script-enrichment node:
+
+- **Executable** - the node has concrete runtime metadata, declared input/output
+  variables, mappings to downstream variables, and no unresolved placeholder.
+- **Draft** - the BPMN shape and intent are present, but runtime metadata,
+  binding, schema, or enrichment is unresolved.
+- **Mock** - the node returns fixed sample data or bypasses the real external
+  action.
+- **Blocked** - required user, tenant, connection, schema, URL, or credential
+  information is missing.
+
+Do not use "fully implemented" for a process that contains draft, mock, or
+blocked nodes. Name those nodes explicitly and state what is still required.