@uipath/skills 1.195.0

package/skills/uipath-maestro-bpmn/references/author/references/plugins/queues/impl.md

@@ -0,0 +1,29 @@
+# Queue Implementation
+
+This document defines the implementation boundary for queue task recipes. See [task-recipes/queue.md](../../task-recipes/queue.md).
+
+## Model-owned implementation
+
+The model may edit:
+
+- `bpmn:sendTask` wrapper for `Orchestrator.CreateQueueItem`.
+- `bpmn:serviceTask` wrapper for `Orchestrator.CreateAndWaitForQueueItem`.
+- Documented queue `uipath:activity` shell.
+- Input CDATA for item payload, reference, priority, deadline, and transaction data.
+- Output mappings for queue item ID, status, or correlation fields.
+- Boundary error handling.
+
+## CLI or operator-owned implementation
+
+The CLI or operator must resolve:
+
+- Real queue binding, folder scope, and generated package resources.
+- Tenant-specific queue names, IDs, or folder keys.
+- Queue schema or downstream callback contracts when required.
+
+## Validation expectations
+
+- Queue binding expression resolves.
+- Payload fields come from declared variables through `vars.<variableId>` or literals.
+- Outputs map to declared writable variables.
+- Duplicate reference and unavailable-resource paths are modeled when required.

package/skills/uipath-maestro-bpmn/references/author/references/plugins/queues/planning.md

@@ -0,0 +1,29 @@
+# Queue Planning
+
+Use this reference when planning Orchestrator queue interactions from BPMN. Queue create is `bpmn:sendTask`; create-and-wait queue work is `bpmn:serviceTask`. See [task-recipes/queue.md](../../task-recipes/queue.md).
+
+## When to use
+
+- Creating queue items.
+- Routing based on queue submission results.
+- Adding transaction metadata or references.
+- Using queue work as a handoff to another automation.
+
+## Planning steps
+
+1. Identify queue operation and whether BPMN only creates an item or also waits for downstream completion.
+2. Define item payload, reference, priority, deadline, and result variables.
+3. Plan queue resource binding with placeholders unless a public-safe binding is provided.
+4. Add error handling for duplicate references, validation failures, and unavailable queues.
+5. Keep downstream processing outside BPMN unless explicitly modeled as a wait or callback.
+
+## Model may draft
+
+- `bpmn:sendTask` with documented `Orchestrator.CreateQueueItem` shell, or `bpmn:serviceTask` with `Orchestrator.CreateAndWaitForQueueItem`.
+- Queue payload CDATA with synthetic fields.
+- Output mappings and error paths.
+- Placeholder-safe binding references.
+
+## Stop conditions
+
+Stop before Operate when the queue resource, folder scope, payload schema, or retry/error behavior is unresolved.

package/skills/uipath-maestro-bpmn/references/author/references/plugins/rpa-jobs/impl.md

@@ -0,0 +1,35 @@
+# RPA Job Implementation
+
+This document defines the implementation boundary for RPA job task recipes. RPA jobs are implemented as `bpmn:serviceTask`; see [task-recipes/rpa-job.md](../../task-recipes/rpa-job.md).
+
+Use the canonical shell from
+[shared/wrapper-shells.md](../../../../shared/wrapper-shells.md): a
+`bpmn:serviceTask` containing `uipath:activity version="v1"` and nested
+`uipath:type value="Orchestrator.StartJob" version="v1"`, with job arguments
+and outputs as direct `uipath:activity` children.
+
+## Model-owned implementation
+
+The model may edit:
+
+- `bpmn:serviceTask` wrapper for RPA job execution.
+- Documented `Orchestrator.StartJob` `uipath:activity` shell.
+- Input CDATA for job arguments in `uipath:activity` using `vars.<variableId>` references.
+- `uipath:activity` outputs for job result, status, outputs, and exception fields.
+- Retry, timeout, and boundary error paths.
+
+## CLI or operator-owned implementation
+
+The CLI or operator must resolve:
+
+- Real process, release, folder, robot, and binding metadata.
+- Generated package resources and argument schemas.
+- Creation or update of the RPA automation itself.
+
+## Validation expectations
+
+- Process binding expression resolves.
+- Argument names match the resolved process contract.
+- Wait and timeout behavior is explicit.
+- Outputs map to declared writable variable ids.
+- No release keys, folder IDs, robot names, or exported private metadata are committed.

package/skills/uipath-maestro-bpmn/references/author/references/plugins/rpa-jobs/planning.md

@@ -0,0 +1,29 @@
+# RPA Job Planning
+
+Use this reference when planning Orchestrator RPA process execution from BPMN. RPA jobs are resource recipes for `bpmn:serviceTask`, not peer BPMN element types. See [task-recipes/rpa-job.md](../../task-recipes/rpa-job.md).
+
+## When to use
+
+- Starting an unattended or attended process job.
+- Passing BPMN variables into an RPA process.
+- Waiting for job result or routing by status.
+- Handling job faults, timeouts, and business exceptions.
+
+## Planning steps
+
+1. Identify process, folder/resource scope, input arguments, output arguments, and wait behavior.
+2. Decide if the BPMN path should continue after starting the job or wait for completion.
+3. Plan job ID, status, output, and error variables.
+4. Add boundary timeout/error behavior and retry intent.
+5. Use placeholder-safe bindings unless the operator provides public-safe resource references.
+6. Hand missing RPA project creation or editing to the RPA skill; do not create it here.
+
+## Model may draft
+
+- `bpmn:serviceTask` wrapper with documented `Orchestrator.StartJob` shell.
+- Input/output mappings and error paths.
+- Public-safe binding placeholders and diagram geometry.
+
+## Stop conditions
+
+Stop before Operate when process identity, folder binding, argument schema, or wait semantics are unresolved.

package/skills/uipath-maestro-bpmn/references/author/references/plugins/script/impl.md

@@ -0,0 +1,118 @@
+# Script Implementation
+
+This document defines the implementation boundary for script tasks.
+
+## Model-owned implementation
+
+The model may edit:
+
+- `bpmn:scriptTask` with `scriptFormat="JavaScript"`.
+- `bpmn:script` content in CDATA.
+- `uipath:scriptVersion`.
+- `uipath:mapping` for `args` input and outputs.
+- Declared variables and JSON schemas used by the script.
+- Boundary error paths.
+
+## Implementation rules
+
+- Script tasks execute through Jint, not Node.js or a browser runtime.
+- Keep script source deterministic and side-effect-light.
+- Keep the XML mapping input named `args`, but read mapped fields as top-level
+  script identifiers. For example, a mapped `caseId` field is available as
+  `caseId`, not `args.caseId`.
+- When mapping BPMN variables into script inputs, use runtime variable-id
+  expressions such as `=vars.Var_CaseId`, not bare names such as `=caseId`.
+- Return or map explicit outputs instead of mutating undeclared globals.
+- Script output mappings must target variables through the `var` attribute.
+  Do not put the target variable id in `name`. Use `name` for the output
+  field/display name and `var` for the declared BPMN variable id:
+
+  ```xml
+  <bpmn:process id="Process_RiskScore" isExecutable="true">
+    <bpmn:extensionElements>
+      <uipath:variables version="v1">
+        <uipath:input id="Var_Amount" name="amount" type="number" elementId="Start_Manual" />
+        <uipath:input id="Var_DaysOverdue" name="daysOverdue" type="number" elementId="Start_Manual" />
+        <uipath:output id="Var_RiskScore" name="riskScore" type="number" />
+      </uipath:variables>
+    </bpmn:extensionElements>
+    ...
+  </bpmn:process>
+  ```
+
+  ```xml
+  <uipath:mapping version="v1">
+    <uipath:type value="BPMN.ScriptTask" version="v1" />
+    <uipath:input name="args"><![CDATA[
+      {"amount":"=vars.Var_Amount","daysOverdue":"=vars.Var_DaysOverdue"}
+    ]]></uipath:input>
+    <uipath:output name="riskScore" type="number" var="Var_RiskScore" source="=result.response" />
+  </uipath:mapping>
+  ```
+- Prefer `uipath:scriptVersion value="v3"` unless preserving an imported version.
+- Available helpers are limited to `uipath.aggregate`, `uipath._aggregate`, `uipath._pipe`, and no-op `console` methods.
+- Do not use npm packages, filesystem, network, browser globals, or long-running async behavior.
+- Keep execution within the 64 MB memory and 30 second timeout envelope.
+- Do not embed secrets, account data, URLs, or local paths.
+- Do not use scripts as a substitute for connector enrichment or RPA work.
+
+## Minimal Jint script task shell
+
+Copy this shape when authoring a new BPMN script task. It is the exact
+mapping shape Maestro expects: `uipath:input name="args"`
+wraps the mapped fields, the script body reads top-level identifiers,
+and the output maps back through `=result.response` for scalar returns or
+`=result.response.<field>` for object fields.
+
+```xml
+<bpmn:scriptTask id="Task_RiskScore" name="Risk Score" scriptFormat="JavaScript">
+  <bpmn:extensionElements>
+    <uipath:scriptVersion value="v3" />
+    <uipath:mapping version="v1">
+      <uipath:type value="BPMN.ScriptTask" version="v1" />
+      <uipath:context>
+        <uipath:inputSchema><![CDATA[{"type":"object","properties":{"amount":{"type":"number"},"daysOverdue":{"type":"number"}}}]]></uipath:inputSchema>
+      </uipath:context>
+      <uipath:input name="args" type="json" target="bodyField"><![CDATA[{"amount":"=vars.Var_Amount","daysOverdue":"=vars.Var_DaysOverdue"}]]></uipath:input>
+      <uipath:output name="riskScore" type="number" var="Var_RiskScore" source="=result.response" />
+    </uipath:mapping>
+  </bpmn:extensionElements>
+  <bpmn:incoming>Flow_Start_To_RiskScore</bpmn:incoming>
+  <bpmn:outgoing>Flow_RiskScore_To_End</bpmn:outgoing>
+  <bpmn:script><![CDATA[
+var score = amount * 0.01 + daysOverdue * 2;
+return { response: score };
+]]></bpmn:script>
+</bpmn:scriptTask>
+```
+
+Required pieces:
+
+| Position | Required token | Why |
+| --- | --- | --- |
+| `bpmn:scriptTask` attribute | `scriptFormat="JavaScript"` | Selects the Jint executor |
+| `uipath:scriptVersion` | `value="v3"` for new scripts; preserve `value="v2"` only on imports | Selects the script contract |
+| `uipath:input` | `name="args"` | The canvas merges `args` JSON into top-level script identifiers |
+| `uipath:input` body | `=vars.<variableId>` for each mapped field | Reads root variables by id, not by name |
+| `bpmn:script` CDATA | top-level identifiers (`amount`, `daysOverdue`); not `args.amount` | Jint sees the merged JSON as top-level vars |
+| `uipath:output` | `source="=result.response"` for scalar returns, or `source="=result.response.<field>"` for object fields; `var` points at a declared variable id | Maps the script return back to a declared variable |
+
+Anti-patterns the checker rejects:
+
+- `uipath:input` with `name` other than `args`.
+- Bare `=amount` style expressions instead of `=vars.Var_Amount`.
+- `args.amount` style reads inside the script body.
+- Missing `uipath:scriptVersion` when the canvas requires it.
+- Returning a bare value instead of `{ response: ... }` for `v2+` mappings.
+- Mapping object returns with `source="=result.summary"` after returning
+  `{ summary: "..." }`; use `source="=result.response.summary"` instead.
+
+## Validation expectations
+
+- Input variables exist and are readable.
+- Output variables exist and are writable.
+- Script CDATA is syntactically coherent.
+- `uipath:scriptVersion` is present when required by the local contract.
+- For `v2` and later, returned JSON maps through `=result.response` or a field
+  below it, such as `=result.response.status`; older script versions must
+  return a JSON object.

package/skills/uipath-maestro-bpmn/references/author/references/plugins/script/planning.md

@@ -0,0 +1,30 @@
+# Script Planning
+
+Use this reference when planning BPMN script tasks.
+
+## When to use
+
+- Deterministic in-process data transformation.
+- Small validation or routing helper logic.
+- Preparing request bodies for downstream tasks.
+- Normalizing outputs before gateways or end events.
+
+## Planning steps
+
+1. Confirm the logic belongs inside BPMN instead of an RPA job, API workflow, agent, or connector.
+2. Define input variables, output variables, and error behavior.
+3. Keep scripts small, deterministic, and public-safe.
+4. Plan `args` input shape and output mappings.
+5. Add boundary error handling when script failure should be recoverable.
+6. Avoid secrets, tenant data, network calls, and private examples.
+
+## Model may draft
+
+- `bpmn:scriptTask` with JavaScript script CDATA.
+- `uipath:scriptVersion`.
+- Input and output mappings using declared variables. See [impl.md](impl.md#minimal-jint-script-task-shell) for the exact required shape.
+- Diagram geometry and surrounding error paths.
+
+## Stop conditions
+
+Stop when the script needs secrets, network access, long-running work, external packages, or customer-specific logic that should be implemented outside BPMN.

package/skills/uipath-maestro-bpmn/references/author/references/plugins/sequence-flows/impl.md

@@ -0,0 +1,30 @@
+# Sequence Flow Implementation
+
+This document defines the implementation boundary for BPMN sequence flows.
+
+## Model-owned implementation
+
+The model may edit:
+
+- `bpmn:sequenceFlow` with `id`, `sourceRef`, `targetRef`, and optional `name`.
+- `bpmn:conditionExpression` bodies.
+- `incoming` and `outgoing` child references on flow nodes.
+- Gateway `default` attributes that reference sequence flows.
+- `bpmndi:BPMNEdge` waypoints.
+
+## Implementation rules
+
+- Keep sequence flows inside one process or subprocess scope.
+- Use `xsi:type="bpmn:tFormalExpression"` for condition expressions when the file uses that convention.
+- Use a leading `=` for UiPath runtime expressions and follow
+  [expression-authoring.md](../../../../shared/expression-authoring.md).
+- Do not attach conditions to outgoing flows from parallel gateways.
+- Update both XML references and diagram edges together.
+
+## Validation expectations
+
+- Every sequence flow source and target exists.
+- Connected elements reference the sequence flow consistently.
+- Conditional expressions parse and use `vars.<variableId>` for declared variables.
+- Default flows are not also treated as mandatory conditional branches.
+- Every visible sequence flow has a BPMN DI edge.

package/skills/uipath-maestro-bpmn/references/author/references/plugins/sequence-flows/planning.md

@@ -0,0 +1,30 @@
+# Sequence Flow Planning
+
+Use this reference when planning control-flow edges between BPMN nodes in the same scope.
+
+## When to use
+
+- Connecting tasks, events, gateways, and subprocesses.
+- Adding branch conditions or default routes.
+- Re-routing existing process paths.
+- Adding diagram waypoints for Studio Web rendering.
+
+## Planning steps
+
+1. Identify source and target elements and confirm they are in the same BPMN scope.
+2. Decide whether the flow is unconditional, conditional, or a gateway default.
+3. Name flows only when the label helps reviewers understand a branch.
+4. Plan expressions from declared variables and mappings.
+5. Update diagram waypoints with readable routing.
+6. Check downstream joins and end states after every route change.
+
+## Model may draft
+
+- `bpmn:sequenceFlow` elements.
+- Conditional expressions and default-route labels.
+- Incoming and outgoing references on connected nodes.
+- BPMN DI edges and waypoints.
+
+## Stop conditions
+
+Stop when a requested route crosses subprocess, event subprocess, or participant boundaries; use message flow, call activity, or subprocess modeling instead.

package/skills/uipath-maestro-bpmn/references/author/references/plugins/service-tasks/impl.md

@@ -0,0 +1,33 @@
+# Service Task Implementation
+
+This document defines the implementation boundary for `bpmn:serviceTask`. Resource-backed task choices live in [task-recipes/](../../task-recipes/).
+
+## Model-owned implementation
+
+The model may edit:
+
+- `bpmn:serviceTask` elements, flow references, and diagram shapes.
+- `uipath:mapping` for declared variables.
+- `uipath:retry`, `uipath:errorMapping`, and tags when explicitly requested;
+  use [error-handling.md](../../../../shared/error-handling.md) for current shapes.
+- Documented non-Integration-Service `uipath:activity` shells with public-safe context.
+- Boundary error or timeout events attached to the task.
+
+Use service tasks for `Orchestrator.StartJob`, `Orchestrator.StartAgentJob`, `A2A.AgentExecution`, `Orchestrator.ExecuteApiWorkflowAsync`, `Orchestrator.CreateAndWaitForQueueItem`, and supported `Intsvc.*` service executions. Do not use a service task for new queue-create, HITL, business-rule, script, or call-activity XML.
+
+## CLI-owned implementation
+
+The CLI must enrich or validate:
+
+- Integration Service payloads.
+- Dynamic schemas and generated outputs.
+- Binding resources in generated package files.
+- Real resource identifiers for cloud-side execution.
+
+## Validation expectations
+
+- Required service context fields exist for the selected type.
+- Inputs reference declared variables with `vars.<variableId>` or use literals.
+- Outputs map to declared writable variables.
+- Binding expressions resolve to root `uipath:bindings` or generated bindings.
+- Boundary events use valid event definitions and stay in scope.

package/skills/uipath-maestro-bpmn/references/author/references/plugins/service-tasks/planning.md

@@ -0,0 +1,31 @@
+# Service Task Planning
+
+Use this reference when planning BPMN service tasks. For resource-specific wrappers, read [task-recipes/](../../task-recipes/) after choosing the BPMN element.
+
+## When to use
+
+- System work represented by `bpmn:serviceTask`.
+- UiPath extension-backed service shells.
+- Draft placeholders for connector, agent, RPA, API workflow, or create-and-wait queue calls.
+- Service work that needs retry, error mapping, input mapping, or output mapping.
+
+## Planning steps
+
+1. Confirm the BPMN element is actually a service task. Queue create, business rules, HITL, and call activity work use other BPMN task classes.
+2. Identify the service owner: model-authored shell, CLI-enriched connector, Orchestrator resource, or external dependency.
+3. Decide whether the task can be implemented now or must remain a draft placeholder.
+4. List required inputs, outputs, bindings, retry behavior, and boundary error paths.
+5. Declare variables before mapping task outputs.
+6. Plan resource bindings with placeholder-safe IDs only.
+7. Add diagram geometry and surrounding flows.
+
+## Model may draft
+
+- Standard `bpmn:serviceTask` wrappers.
+- Public-safe IDs, labels, mappings, retries, and boundary errors.
+- Documented non-Integration-Service `uipath:activity` shells.
+- Placeholders for CLI-owned service details.
+
+## Stop conditions
+
+Stop before upload/run when required service type metadata, resource binding, input schema, output schema, or executable context is missing.

package/skills/uipath-maestro-bpmn/references/author/references/plugins/signals/impl.md

@@ -0,0 +1,33 @@
+# Signal Implementation
+
+This document defines the preserve-only boundary for BPMN signals.
+
+## Preserve-only implementation
+
+The model may preserve imported:
+
+- Root `bpmn:signal` definitions.
+- `bpmn:signalEventDefinition` references on start, intermediate, boundary, and end events.
+- Signal throw/catch sequence flows and event subprocesses.
+- Public-safe payload variable mappings.
+- Diagram shapes and edges.
+
+Do not generate new signal definitions, signal event definitions, signal
+throws, signal catches, or signal-based event subprocesses in new source.
+
+## CLI or operator-owned implementation
+
+The CLI or operator must resolve:
+
+- Any runtime subscription or cross-process signal binding outside standard BPMN XML.
+- Payload schemas that are generated by a runtime resource.
+- Tenant-specific channel, folder, or resource identifiers.
+- Correlation, idempotency, and fan-out expectations when multiple deployed instances can catch the signal.
+- Validation evidence that the deployed runtime supports the imported signal event shape.
+
+## Validation expectations
+
+- Imported signal event definitions still reference existing signal definitions.
+- Unrelated edits preserve imported signal XML and diagram geometry.
+- Any claim that an imported signal is executable has current runtime validation
+  evidence outside this model-authored XML.

package/skills/uipath-maestro-bpmn/references/author/references/plugins/signals/planning.md

@@ -0,0 +1,46 @@
+# Signal Planning
+
+Signals are preserve-only for current Maestro BPMN authoring. Use this
+reference only when inspecting or preserving imported signal throw/catch
+behavior.
+
+## When to use
+
+- An imported or brownfield BPMN file already contains signal definitions or
+  signal event definitions.
+- The user asks why signal-based behavior is not regenerated.
+- You need to preserve imported signal XML while editing unrelated supported
+  process structure.
+
+## Planning steps
+
+1. Identify the existing signal definitions and event references.
+2. Preserve them unchanged unless the user explicitly asks to remove or replace
+   them.
+3. Route new behavior through supported message, timer, receive-task,
+   Integration Service, or gateway patterns instead of adding new signals.
+4. Report that signal regeneration is unsupported until current product and CLI
+   validation confirm it.
+
+## Executable boundary
+
+Do not generate new `bpmn:signal` definitions or
+`bpmn:signalEventDefinition` elements in new source.
+
+- Preserve-only: imported `bpmn:signal` definitions, signal event references,
+  local throw/catch topology, labels, variables, mappings, and diagram
+  geometry.
+- Unsupported for regeneration: runtime subscription registration,
+  cross-process correlation, payload schema versioning, tenant/folder/resource
+  identifiers, and any non-BPMN binding needed for deployed execution.
+
+## Model may draft
+
+- No new signal BPMN.
+- Only preservation of imported signal XML while applying unrelated supported
+  edits.
+
+## Stop conditions
+
+Stop before Operate when imported signal behavior is expected to execute and no
+current runtime validation evidence is available.

package/skills/uipath-maestro-bpmn/references/author/references/plugins/start-end-events/impl.md

@@ -0,0 +1,59 @@
+# Start, End, and Event Implementation
+
+This document defines the implementation boundary for BPMN events.
+
+## Model-owned implementation
+
+The model may edit:
+
+- `bpmn:startEvent`, `bpmn:endEvent`, `bpmn:intermediateCatchEvent`, `bpmn:intermediateThrowEvent`, and `bpmn:boundaryEvent`.
+- Standard event definitions such as timer, message, error, and terminate end events where supported.
+- Event IDs, names, `attachedToRef`, `cancelActivity`, incoming/outgoing flows, and BPMN DI.
+- Root `uipath:entryPointId` values for root starts.
+- `uipath:mapping` entries for event input/output movement.
+- Documented non-Integration-Service `uipath:event` shells such as Maestro message events.
+
+Message event boundaries:
+
+- Use `Maestro.ReceiveMessageEvent` for model-owned message starts, intermediate catches, and boundary waits when the message name and payload contract are known.
+- Use `Maestro.SendMessageEvent` for model-owned message throws and message end events when the message name and payload contract are known.
+- Use `Intsvc.EventTrigger` and `Intsvc.WaitForEvent` only through CLI enrichment because connector event metadata, bindings, trigger properties, and schemas are registry-backed.
+
+Boundary event flow rules:
+
+- A boundary event has no incoming flow.
+- A boundary event lists each exception/timeout sequence flow as its own
+  `bpmn:outgoing` child.
+- The attached activity lists only its normal incoming and outgoing flows. Do
+  not add boundary-event exception flows as normal activity incoming or
+  outgoing flows.
+- The exception sequence flow uses `sourceRef` equal to the boundary event ID
+  and `targetRef` equal to the recovery or review target.
+- Error boundary events must reference a declared root `bpmn:error`.
+- Add BPMN DI for the boundary event shape and for each outgoing exception
+  sequence flow.
+
+## CLI-owned or externally resolved implementation
+
+The CLI or operator must resolve:
+
+- Integration Service trigger and wait metadata.
+- Trigger property bindings and generated schemas.
+- Real connection, folder, queue, or external-system identifiers.
+- Cloud-side subscription, schedule, or correlation resources.
+
+## Validation expectations
+
+- Root runnable starts have unique entry point IDs.
+- Entry point variables reference the owning start event.
+- Event subprocesses have exactly one valid start event.
+- Boundary events attach to an activity in the same scope.
+- Boundary events have outgoing sequence flow children for their exception
+  paths, and the attached activity does not list those exception flows as
+  normal incoming/outgoing activity flows.
+- Message and error references resolve.
+- Every visible event and event flow has diagram geometry.
+
+Excluded event definitions from
+[supported-elements.md](../../supported-elements.md#current-generation-exclusions)
+are preserve-only for imported files.

package/skills/uipath-maestro-bpmn/references/author/references/plugins/start-end-events/planning.md

@@ -0,0 +1,37 @@
+# Start, End, and Event Planning
+
+Use this reference when planning BPMN start events, end events, intermediate events, and boundary events.
+
+## When to use
+
+- Manual, timer, message, or trigger-driven starts.
+- Normal, terminate, error, or message ends.
+- Intermediate catch or throw events in the process body.
+- Boundary events attached to activities for timeout, error, or message paths.
+
+## Planning steps
+
+1. Identify whether the event starts work, waits for work, throws a notification, handles an exception, or finishes the process.
+2. Choose the BPMN event type and event definition before adding UiPath metadata.
+3. Determine scope: root process, subprocess, event subprocess, or activity boundary.
+4. Decide entry point status for root start events and list required entry variables.
+5. Plan event outputs and mappings to process variables.
+6. Record any runtime resource that needs CLI enrichment, especially connector-backed triggers or waits.
+7. Plan outgoing sequence flows, boundary escape paths, and end-state outputs.
+
+## Model may draft
+
+- Standard BPMN event elements and event definitions.
+- `uipath:entryPointId` for runnable root start events.
+- Public-safe IDs, labels, mappings, and diagram geometry.
+- Message or error definitions with synthetic names.
+- Boundary attachment and interrupting versus non-interrupting intent.
+
+## Stop conditions
+
+Stop before Operate when an event depends on unresolved connector metadata, trigger properties, dynamic schema, real message correlation contract, or private identifiers.
+
+Do not generate event definitions listed in
+[supported-elements.md](../../supported-elements.md#current-generation-exclusions)
+for new source. Preserve imported instances and report them as unsupported for
+regeneration.

package/skills/uipath-maestro-bpmn/references/author/references/plugins/waits-triggers/impl.md

@@ -0,0 +1,40 @@
+# Wait and Trigger Implementation
+
+This document defines the implementation boundary for waits and triggers.
+
+## Model-owned implementation
+
+The model may edit:
+
+- Timer, message, and boundary event definitions.
+- Receive-task or event-based-gateway structures.
+- Entry point metadata for runnable starts.
+- Public-safe correlation variable names and mappings.
+- Non-Integration-Service message event shells when documented.
+
+Do not duplicate message-event concepts:
+
+- Plain BPMN message events describe process semantics.
+- `Maestro.ReceiveMessageEvent` and `Maestro.SendMessageEvent` are model-owned UiPath message-event shells.
+- Connector-backed waits and triggers use `Intsvc.WaitForEvent` or `Intsvc.EventTrigger` and require CLI enrichment.
+
+## CLI-owned or operator-owned implementation
+
+The CLI or operator must provide:
+
+- Integration Service trigger/wait context and schemas.
+- Schedule resource details when they are cloud-owned.
+- Real correlation identifiers, subscriptions, and binding resources.
+- Generated package files for executable triggers.
+
+## Validation expectations
+
+- Start triggers are valid entry points.
+- Intermediate waits have a path to resume or time out.
+- Boundary timers attach to valid activities.
+- Event schemas and output mappings resolve.
+- Connector-backed waits are enriched before upload/run.
+
+Excluded event definitions from
+[supported-elements.md](../../supported-elements.md#current-generation-exclusions)
+are preserve-only for imported files.

package/skills/uipath-maestro-bpmn/references/author/references/plugins/waits-triggers/planning.md

@@ -0,0 +1,34 @@
+# Wait and Trigger Planning
+
+Use this reference when planning process starts or pauses that wait for time, messages, schedules, or external events.
+
+## When to use
+
+- Timer starts or timer intermediate events.
+- Message or connector-backed starts.
+- Intermediate waits for messages or external connector events.
+- Timeout branches and boundary timers.
+
+## Planning steps
+
+1. Identify whether the wait begins the process, pauses the current path, or interrupts an activity.
+2. Choose timer, message, receive task, event-based gateway, or connector trigger shape.
+3. Define correlation inputs and outputs in public-safe terms.
+4. Plan timeout and cancellation behavior.
+5. Mark Integration Service trigger or wait enrichment as CLI-owned.
+6. Confirm whether the process may resume with stale data and how outputs update variables.
+
+## Model may draft
+
+- Standard timer, message, and boundary event structure.
+- Receive/wait task wrappers for non-connector message waits.
+- `uipath:event` shells for documented non-Integration-Service events.
+- Entry point IDs and variable mappings.
+
+## Stop conditions
+
+Stop before Operate when schedule, trigger properties, correlation contract, connector metadata, or dynamic event schema is unresolved.
+
+Do not generate signal, conditional, escalation, compensation, cancel, link,
+multiple, or parallel-multiple event definitions for new Maestro BPMN source.
+Preserve imported instances only.