@uipath/skills 1.201.0-preview.621 → 1.202.0-preview.635

package/skills/uipath-maestro-flow/references/author/plugins/subflow/impl.md

@@ -0,0 +1,164 @@
+# Subflow Node — Implementation
+
+## Node Type and Registry Validation
+
+`core.subflow`
+
+Run:
+
+```bash
+uip maestro flow registry get core.subflow --output json
+```
+
+Confirm input port `input` and output ports `output` and `error`. Set the node instance `typeVersion` to the response's `version` field; do not hardcode it.
+
+## Parent Node JSON
+
+```json
+{
+  "id": "subflow1",
+  "type": "core.subflow",
+  "typeVersion": "<DEFINITION_VERSION>",
+  "display": { "label": "Add Numbers", "icon": "layers" },
+  "inputs": { "a": 2, "b": 3 },
+  "outputs": {
+    "error": {
+      "type": "object",
+      "description": "Error information if the subflow fails",
+      "source": "=Error",
+      "var": "error"
+    }
+  }
+}
+```
+
+Declare `error` only; `output` is derived. Do not author `output`: the converter copies its `source` verbatim, so `"=result.response"` resolves to null at runtime although `flow validate` passes. See [file-format.md § Node outputs](../../../shared/file-format.md#node-outputs).
+
+## Subflow Definition
+
+Store definitions in a top-level `subflows` object keyed by the parent node ID. Each definition contains `nodes`, `edges`, `variables`, and `layout`:
+
+```json
+{
+  "subflows": {
+    "subflow1": {
+      "nodes": [
+        {
+          "id": "subflow1Start",
+          "type": "core.trigger.manual",
+          "typeVersion": "1.0",
+          "display": { "label": "Start" },
+          "inputs": { "entryPointId": "<unique-uuid>", "isDefaultEntryPoint": true },
+          "outputs": {
+            "output": {
+              "type": "object",
+              "description": "Data passed when manually triggering the workflow.",
+              "source": "null",
+              "var": "output"
+            }
+          }
+        },
+        {
+          "id": "script1",
+          "type": "core.action.script",
+          "typeVersion": "1.0",
+          "display": { "label": "Add Numbers" },
+          "inputs": { "script": "return { result: $vars.subflow1Start.output.a + $vars.subflow1Start.output.b };" },
+          "outputs": {
+            "output": { "type": "object", "description": "The return value of the script", "source": "=result.response", "var": "output" },
+            "error": { "type": "object", "description": "Error information if the script fails", "source": "=Error", "var": "error" }
+          }
+        },
+        {
+          "id": "subflow1End",
+          "type": "core.control.end",
+          "typeVersion": "1.0",
+          "display": { "label": "End" },
+          "inputs": {},
+          "outputs": { "result": { "source": "=js:$vars.script1.output.result" } }
+        }
+      ],
+      "edges": [
+        { "id": "sf-e1", "sourceNodeId": "subflow1Start", "sourcePort": "output", "targetNodeId": "script1", "targetPort": "input" },
+        { "id": "sf-e2", "sourceNodeId": "script1", "sourcePort": "success", "targetNodeId": "subflow1End", "targetPort": "input" }
+      ],
+      "variables": {
+        "globals": [
+          { "id": "a", "direction": "in", "type": "number", "defaultValue": 0, "triggerNodeId": "subflow1Start" },
+          { "id": "b", "direction": "in", "type": "number", "defaultValue": 0, "triggerNodeId": "subflow1Start" },
+          { "id": "result", "direction": "out", "type": "number", "defaultValue": 0 }
+        ],
+        "nodes": []
+      },
+      "layout": {
+        "nodes": {
+          "subflow1Start": { "position": { "x": 200, "y": 144 }, "size": { "width": 96, "height": 96 }, "collapsed": false },
+          "script1": { "position": { "x": 400, "y": 144 }, "size": { "width": 96, "height": 96 }, "collapsed": false },
+          "subflow1End": { "position": { "x": 600, "y": 144 }, "size": { "width": 96, "height": 96 }, "collapsed": false }
+        }
+      }
+    }
+  }
+}
+```
+
+## Passing a Flow Input Into the Subflow
+
+Set `triggerNodeId` on the parent's `in` variable when forwarding trigger input. Run `uip maestro flow validate`; do not treat **Valid** as proof that this is configured. Without `triggerNodeId`, `flow debug` shows an empty trigger output, forwards `null`, and may fault in the subflow (for example, `Cannot read property 'split' of null`).
+
+```json
+{
+  "variables": {
+    "globals": [
+      { "id": "text", "direction": "in", "type": "string", "defaultValue": "", "triggerNodeId": "start" },
+      { "id": "reversedText", "direction": "out", "type": "string", "defaultValue": "" }
+    ]
+  },
+  "nodes": [
+    {
+      "id": "start",
+      "type": "core.trigger.manual",
+      "typeVersion": "1.0",
+      "inputs": { "entryPointId": "<uuid>", "isDefaultEntryPoint": true },
+      "outputs": { "output": { "type": "object", "description": "Data passed when manually triggering the process.", "source": "null", "var": "output" } }
+    },
+    {
+      "id": "reverseSubflow",
+      "type": "core.subflow",
+      "typeVersion": "<DEFINITION_VERSION>",
+      "inputs": { "text": "=js:$vars.start.output.text" }
+    }
+  ]
+}
+```
+
+Value flow is: caller input `text` → parent `start` through the parent's `triggerNodeId` → `$vars.start.output.text` → subflow input `text` → the subflow's `in` variable → `$vars.<subflowStart>.output.text`. Parent and subflow `in` variables are independent; set `triggerNodeId` for each.
+
+## Subflow Rules
+
+1. Every subflow must have its own Start node (`core.trigger.manual`) and End node (`core.control.end`).
+2. Subflow `variables.globals` with `direction: "in"` map to parent node `inputs`.
+3. Subflow `in` variables must set `triggerNodeId` to the subflow Start node ID, enabling `$vars.{startNodeId}.output.{varId}`.
+4. Subflow `variables.globals` with `direction: "out"` map to parent node outputs and are accessible as `$vars.{subflowNodeId}.output` in the parent.
+5. Parent-scope `$vars` are not visible inside the subflow; pass values explicitly through inputs.
+6. Define inline `outputs` on every subflow node: Start needs `outputs.output`; Script nodes need `outputs.output` and `outputs.error`.
+7. Subflows may be nested up to 3 levels.
+8. Each subflow has its own `nodes`, `edges`, `variables`, and `layout` sections.
+9. Put subflow node positions in that subflow's `layout.nodes`, not the top-level `layout.nodes`; scopes are independent.
+10. When the parent forwards an external input, its `in` variable must also set `triggerNodeId` to the parent trigger node ID. `uip maestro flow validate` does not detect this omission; the value silently arrives `null`. See [Passing a Flow Input Into the Subflow](#passing-a-flow-input-into-the-subflow).
+
+## Creating a Subflow
+
+For the procedure, see [Edit/Write: Create a subflow](../../editing-operations-json.md#create-a-subflow). Use the structures above for node-specific fields.
+
+## Debug
+
+| Error | Cause | Fix |
+| --- | --- | --- |
+| `$vars.inputData` undefined inside subflow script | Missing `triggerNodeId` on a subflow `in` variable, or direct use of `$vars.{varId}` | Set `triggerNodeId: "{startNodeId}"` on each `in` variable and use `$vars.{startNodeId}.output.{varId}` |
+| Subflow script receives `null`, such as `Cannot read property 'split' of null` | Parent `in` variable lacks `triggerNodeId`, leaving parent trigger output empty | Set `triggerNodeId: "{parentStartNodeId}"` on the parent flow's `in` variable |
+| `$vars.parentNode` undefined inside subflow | Parent scope is inaccessible | Pass values through subflow `in` variables |
+| Subflow output is null | End node lacks output mapping | Map all `out` variables in the End node's `outputs` |
+| Script output is null | Script lacks inline `outputs` | Add `outputs.output` and `outputs.error` inline |
+| Missing Start/End node | Required trigger or end is absent | Add `core.trigger.manual` with `outputs` and `entryPointId`, plus `core.control.end` |
+| Nesting limit exceeded | More than 3 levels of nesting | Flatten the structure or use resource nodes for deeper composition |

package/skills/uipath-maestro-flow/references/author/{references/plugins → plugins}/subflow/planning.md

@@ -23,7 +23,7 @@ Use a Subflow node to group related steps into a reusable, drillable container w
 | --- | --- |
 | `input` | `output`, `error` |
 
-The `error` port is the implicit error port shared with all action nodes — see [Implicit error port on action nodes](../../../../shared/file-format.md#implicit-error-port-on-action-nodes).
+The `error` port is the implicit error port shared with all action nodes — see [Implicit error port on action nodes](../../../shared/file-format.md#implicit-error-port-on-action-nodes).
 
 ## Key Properties
 

package/skills/uipath-maestro-flow/references/author/plugins/summarize/impl.md

@@ -0,0 +1,189 @@
+# Summarize Pattern Node — Implementation
+
+Summarize synthesizes a response grounded in an attached document. Node type: `uipath.pattern.deep-rag`; BPMN service task with `serviceType: "ECS.DeepRag"`. Inputs are the only configuration source; there are no process or connection bindings.
+
+## Registry validation
+
+Run:
+
+```bash
+uip maestro flow registry get uipath.pattern.deep-rag --output json
+```
+
+Confirm:
+
+- Input port: `input`; output ports: `output`, `error`.
+- `model.type`: `bpmn:ServiceTask`; `model.serviceType`: `ECS.DeepRag`.
+- `inputDefinition.properties`: `attachment` (declared `string`, but runtime requires the full Flow Attachment object `{ ID, FullName, MimeType, Metadata }`, with case-sensitive keys and uppercase `ID`), `prompt` (string), and `returnCitations` (boolean).
+- `outputDefinition.output.type`: `"object"`; `outputDefinition.output.source`: `"=response"` (the BPMN engine wraps the result under that key, as for every ServiceTask).
+- `outputDefinition.output.schema`: top-level `id` (string) and `content` (object|null), with `content.Text` (string) and `content.Citations` (array|null) containing `{ Ordinal: integer, PageNumber: integer, Source: string, Reference: string }`.
+- `outputDefinition.error.schema.required`: `code`, `message`, `detail`, `category`, `status`.
+
+If the command returns **"Node type not found: uipath.pattern.deep-rag"**, run `uip tools update` and `uip maestro flow registry pull --force`. If it still fails, confirm with a UiPath admin that the tenant's `canvas.nodes.summarize` server flag is enabled.
+
+## Authoring and attachment wiring
+
+Pattern nodes are OOTB BPMN service tasks and are **user-owned** per [Author capability — Node ownership](../../CAPABILITY.md#node-ownership--who-authors-the-node). Author them by editing `.flow` JSON directly (Edit/Write). The `uip maestro flow node add` / `edge add` CLI is reserved for CLI-owned nodes (connectors, connector-triggers, managed HTTP), where the CLI populates product-managed state. Use Edit/Write for OOTB structural edits—adding Summarize, wiring edges, and adding the `attachment` flow input. See [editing-operations.md](../../editing-operations.md).
+
+Declare a flow `in` variable with `type: "file"`, bound to the trigger with `triggerNodeId`, and reference it through the trigger output:
+
+```json
+"variables": {
+  "globals": [{
+    "id": "documentFile",
+    "direction": "in",
+    "type": "file",
+    "triggerNodeId": "start"
+  }]
+}
+```
+
+```json
+"inputs": {
+  "attachment": "=js:$vars.start.output.documentFile",
+  "...": "..."
+}
+```
+
+Populate it by running `uip maestro flow debug --attachment <variableId>=<localPath>`, for example, `--attachment documentFile=./path/to/doc.pdf`. The CLI uploads the file and binds `{ ID, FullName, MimeType, Metadata }`. The flag is repeatable, and `<variableId>` must match a `variables.globals[]` `id`; see [cli-commands.md — Pre-flight](../../../shared/cli-commands.md#pre-flight---attachment-binding).
+
+Do not declare the variable as `type: "object"`; reference it without the trigger output path; or pass a bare GUID, URL, path, `.ID`, or `.FullName`.
+
+## JSON structure and rules
+
+```json
+{
+  "id": "summarizeContract",
+  "type": "uipath.pattern.deep-rag",
+  "typeVersion": "1.0",
+  "display": { "label": "Summarize Contract" },
+  "inputs": {
+    "attachment": "=js:$vars.start.output.documentFile",
+    "prompt": "Write a 5-bullet executive summary covering scope, term, SLAs, penalties, and termination.",
+    "returnCitations": true
+  },
+  "outputs": {
+    "output": {
+      "type": "object",
+      "source": "=response",
+      "var": "output",
+      "schema": {
+        "$schema": "http://json-schema.org/draft-07/schema#",
+        "type": "object",
+        "properties": {
+          "id": { "type": "string" },
+          "content": {
+            "type": ["object", "null"],
+            "properties": {
+              "Text": { "type": "string" },
+              "Citations": {
+                "type": ["array", "null"],
+                "items": {
+                  "type": "object",
+                  "properties": {
+                    "Ordinal": { "type": "integer" },
+                    "PageNumber": { "type": "integer" },
+                    "Source": { "type": "string" },
+                    "Reference": { "type": "string" }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "error": {
+      "type": "object",
+      "description": "Error information if the node fails",
+      "source": "=Error",
+      "var": "error"
+    }
+  }
+}
+```
+
+- Do not add an instance-level `model` block. BPMN type and `serviceType: "ECS.DeepRag"` belong only in the corresponding `definitions[]` entry; copy that entry verbatim from `uip maestro flow registry get uipath.pattern.deep-rag --output json`. Per [Author capability, rule 15](../../CAPABILITY.md), node instances normally have no `model` block.
+- Set `typeVersion` exactly to `definitions[<deep-rag>].version` from the registry. Do not guess; use the exact single-dot `x.y` form, such as `"1.0"`, not `"1.0.0"`.
+- Set `outputs.output.source` literally to `=response`, not `=deepRagResult` or another name.
+- Set `outputs.output.type` to `"object"` with the nested PascalCase schema shown above.
+- `returnCitations: true` populates `content.Citations`; `false` omits it, so downstream consumers must tolerate either form.
+
+## End-node output mapping
+
+Expose results with `=js:` expressions as required by [Author capability, rule 11](../../CAPABILITY.md):
+
+```json
+{
+  "id": "end",
+  "type": "core.control.end",
+  "typeVersion": "1.0",
+  "outputs": {
+    "summary": { "source": "=js:$vars.summarizeContract.output.content.Text" },
+    "citations": { "source": "=js:$vars.summarizeContract.output.content.Citations" }
+  }
+}
+```
+
+Without `=js:`, the runtime stores the literal expression string. Use only `.Text` and `.Citations`; lowercase variants resolve to `undefined`. If `returnCitations: false`, omit the `citations` mapping.
+
+## Add via CLI (opt-in, not preferred)
+
+The `uip maestro flow node add` / `edge add` CLI is not canonical for OOTB pattern nodes; use it only when scripting where Edit/Write is unavailable. Run:
+
+```bash
+uip maestro flow node add <FlowName>.flow uipath.pattern.deep-rag \
+  --label "<LABEL>" \
+  --input '{
+    "attachment": "=js:$vars.<triggerId>.output.<fileVarId>",
+    "prompt": "<INSTRUCTION for the synthesis>",
+    "returnCitations": true
+  }' \
+  --output json
+```
+
+`attachment` must resolve to `{ ID, FullName, MimeType, Metadata }` through `$vars.<triggerId>.output.<fileVarId>`. Do not pass a bare GUID, URL, byte stream, or path. Set `returnCitations: false` or omit it when provenance is unnecessary.
+
+## Accessing output
+
+```javascript
+// Downstream Script node
+const result = $vars.summarizeContract.output;
+const text = result.content.Text;
+const citations = result.content.Citations ?? [];
+return { summary: text, citationCount: citations.length };
+```
+
+Use PascalCase: `Text`, `Citations`, `Ordinal`, `PageNumber`, `Source`, and `Reference`. When citations are disabled, guard with `?? []` or check `result.content.Citations != null` before iterating.
+
+## Validate
+
+Run:
+
+```bash
+uip maestro flow validate <FlowName>.flow --output json
+```
+
+The validator checks that required inputs (`attachment`, `prompt`) are present and non-empty. A bare attachment id can pass validation but fail at runtime.
+
+## Debug
+
+| Error | Cause | Fix |
+| --- | --- | --- |
+| `Node type not found: uipath.pattern.deep-rag` | CLI predates Summarize support, or tenant flag `canvas.nodes.summarize` is off | Run `uip tools update` and `uip maestro flow registry pull --force`; if still missing, check with an admin that `canvas.nodes.summarize` is enabled |
+| Runtime: synthesis returns empty `content.Text` | Prompt is vague, or attachment is unreadable, such as an image-only PDF with no OCR or a corrupted file | Tighten the prompt; confirm the attachment type is supported and has selectable text |
+| `content.Citations` missing despite `returnCitations: true` | A downstream consumer read `inputDefaults` before runtime output existed | Reference `$vars.{nodeId}.output.content.Citations` only in nodes downstream of Summarize; do not precompute |
+| Downstream `result.content.text` / `result.content.citations` is `undefined` | Lowercase field names were used | Use `result.content.Text` / `result.content.Citations` |
+| Large documents time out | Synthesis cost scales with document size and one call is bounded | Split upstream into per-section Summarize calls plus a final merge, or use a published [Agent](../agent/impl.md) with a context-grounding resource |
+| Wrong citations, such as pages off by one or wrong source | Document page numbering differs from displayed page ordinal | Treat `Ordinal` and `PageNumber` as advisory; present `Source`/`Reference` and let the reader verify |
+
+## What not to do
+
+- Do not hand-author `model.bindings`; Summarize has no process or connector binding. Such a block may be stripped or cause validation errors.
+- Do not pass `--source` to `uip maestro flow node add`; `--source` is only for inline agent nodes. Summarize has no agent project behind it.
+- Do not chain Summarize for multi-turn chat. Calls are single-turn and independent; use a published [Agent](../agent/impl.md) for conversational flows.
+- Do not put the entire document text in `prompt`; the attachment is already ingested. Describe the task instead.
+- Do not assume `content.Citations` is always present; it is omitted when `returnCitations: false`.
+- Do not use lowercase field names such as `content.text`, `content.citations`, `.ordinal`, or `.page`; the runtime emits `content.Text`, `content.Citations`, `Ordinal`, `PageNumber`, `Source`, and `Reference`.
+- Do not pass `attachment` as a bare string id, GUID, URL, or path. The runtime requires `{ ID, FullName, MimeType, Metadata }`, with uppercase `ID`, referenced as `=js:$vars.<triggerId>.output.<fileVarId>` from a file-typed flow `in` variable bound with `triggerNodeId`; see Key Inputs in `planning.md`. Bare-id mistakes can pass `flow validate` and fault at runtime.
+- Do not write `outputs.output.source: "=deepRagResult"`; the canonical value is `"=response"`.

package/skills/uipath-maestro-flow/references/author/plugins/summarize/planning.md

@@ -0,0 +1,66 @@
+# Summarize Pattern Node — Planning
+
+The Summarize node comprehensively synthesizes one attached document (PDF, Word, etc.) through ingestion, retrieval, reasoning, and prose output, optionally with per-sentence source-page citations. It is in the **Document Processing** add-node category.
+
+## Node Type
+
+`uipath.pattern.deep-rag`
+
+The wire type remains `deep-rag` although the canvas name is "Summarize"; this is contractual with the runtime serializer. This fixed OOTB type has no registry suffix and one version. It appears only when the platform-side `canvas.nodes.summarize` feature flag is enabled. The uip CLI requests this flag unconditionally in its manifest fetch, so the node appears after server rollout to the tenant. It does not appear in `uip maestro flow registry list` before then.
+
+## When to Use
+
+Use Summarize for **"read this document and produce a thorough answer"** tasks, including summarization, document-grounded Q&A, compliance checks, and executive briefs where depth or source traceability matters.
+
+| Situation | Use Summarize? |
+| --- | --- |
+| Long-document summarization, such as a contract, policy, or research paper | Yes |
+| Free-form question grounded in one attached document | Yes |
+| Reports requiring every claim to cite a source page | Yes — set `returnCitations: true` |
+| Short, single-turn Q&A over small in-memory text | No — use [Agent](../agent/planning.md) or [Script](../script/planning.md) |
+| Row-by-row tabular enrichment | No — use [Batch Transform](../batch-transform/planning.md) |
+| Retrieval across multiple documents | No — Summarize supports one attachment per call. Chain one node per document and merge results, or use a published [Agent](../agent/planning.md) with a context-grounding resource. Do not chain nodes when the answer requires cross-document reasoning; per-document synthesis followed by merging loses cross-document grounding. |
+| Conversational document chat | No — Summarize is single-turn. Use an [Agent](../agent/planning.md) with a context resource. |
+
+### Anti-Patterns
+
+- Do not use Summarize for small or simple text. For a few paragraphs inline in `$vars`, use a [Script](../script/planning.md) or [Agent](../agent/planning.md), which is cheaper and faster.
+- Do not use Summarize as a general agent. It cannot call tools, escalate, or loop; use an [Agent](../agent/planning.md) for multi-step reasoning with tool use.
+
+## Ports
+
+| Port | Position | Direction | Use |
+| --- | --- | --- | --- |
+| `input` | left | target | Flow sequence input |
+| `output` | right | source | Synthesis text, plus citations when enabled |
+| `error` | right | source | Error handler |
+
+There are no artifact ports. Pattern nodes do not wire to resource files; supply the prompt through node inputs.
+
+## Output Variables
+
+`$vars.{nodeId}.output` is an object whose schema is published on the OOTB definition and mirrored in `outputs.output.schema`:
+
+- `id` — string, result identifier
+- `content` — `object | null`
+  - `content.Text` — string, synthesized prose
+  - `content.Citations` — `array | null`, present only when `returnCitations: true`; entries are `{ Ordinal: integer, PageNumber: integer, Source: string, Reference: string }`
+
+Use the exact **PascalCase** names `Text`, `Citations`, `Ordinal`, `PageNumber`, `Source`, and `Reference`. Lowercase variants such as `text`, `citations`, and `page` are incorrect.
+
+`$vars.{nodeId}.error` is populated on failure with `{ code, message, detail, category, status }`.
+
+## Key Inputs
+
+| Input | Required | Type | Description |
+| --- | --- | --- | --- |
+| `attachment` | Yes | full Flow Attachment | Supply the full case-sensitive Flow Attachment object `{ ID, FullName, MimeType, Metadata }`; `ID` is uppercase, not `Id`. Define it as a flow-level `in` variable with `type: "file"`, bound to the trigger using `triggerNodeId: "<triggerId>"`. Populate it with `uip maestro flow debug --attachment <fileVarId>=<path>`; the flag is repeatable and `<fileVarId>=` must match the variable's `id` (see [cli-commands.md — Pre-flight](../../../shared/cli-commands.md#pre-flight---attachment-binding)). Reference it on the node as `=js:$vars.<triggerId>.output.<fileVarId>`, which resolves to the whole Attachment object. Although the OOTB `inputDefinition.attachment` declares `type: "string"` because Studio Web serializes the object into that slot when saving, the engine deserializes it back. Never wire a bare GUID, URL, byte stream, file path, or `.ID`/`.FullName` subfield. |
+| `prompt` | Yes | string | Task instruction, such as an executive summary, a list of SLA penalty clauses, or an answer about a termination notice period. |
+| `returnCitations` | No | boolean | Set to `true` to populate `content.Citations` with per-claim page references; default is `false`. |
+
+## Planning Annotation
+
+In the architectural plan:
+
+- Write `pattern: summarize — <one-line purpose>` with a placeholder for the attachment source: `=js:$vars.<triggerId>.output.<fileVarId>`, referencing a trigger-bound `in` variable of `type: "file"`, plus a short prompt summary.
+- Explicitly call out `returnCitations: true` in the node table when downstream steps display or audit sources; otherwise leave it `false`.

package/skills/uipath-maestro-flow/references/author/plugins/switch/planning.md

@@ -0,0 +1,34 @@
+# Switch Node — Planning
+
+## Node Type
+
+`core.logic.switch`
+
+## Use When
+
+Use a Switch node for multi-way branching with three or more paths based on ordered case expressions. Evaluate cases in order and take the first `true` case.
+
+| Situation | Use Switch? |
+| --- | --- |
+| Three or more paths based on different conditions | Yes |
+| Simple true/false branch | No — use [Decision](../decision/planning.md) |
+| Branch on HTTP response status codes | No — use [HTTP](../http/planning.md) built-in branches |
+| Branch requires reasoning on ambiguous input | No — use [Agent](../agent/planning.md) |
+
+## Ports and Inputs
+
+| Input Port | Output Port(s) |
+| --- | --- |
+| `input` | `case-{id}` for each case, plus optional `default` |
+
+| Input | Required | Description |
+| --- | --- | --- |
+| `cases` | Yes | Array of `{ id, label, expression }` with at least 1 item |
+
+Each case creates the dynamic output port `case-{item.id}`. Use the optional `default` port for unmatched cases.
+
+## Wiring Rules
+
+- Produce one outgoing edge per case, plus optionally one from `default`.
+- Set each case edge's `sourcePort` to `"case-{id}"`, matching the case's `id` field.
+- Ensure every case branch leads to a downstream node.

package/skills/uipath-maestro-flow/references/author/plugins/terminate/impl.md

@@ -0,0 +1,48 @@
+# Terminate Node — Implementation
+
+## Node Type
+
+`core.logic.terminate`
+
+## Registry Validation
+
+Run:
+
+```bash
+uip maestro flow registry get core.logic.terminate --output json
+```
+
+Confirm the input port is `input` and there are no output ports. Set the node instance `typeVersion` to the response's `version` field; do not hardcode it.
+
+## JSON Structure
+
+```json
+{
+  "id": "abortOnError",
+  "type": "core.logic.terminate",
+  "typeVersion": "<DEFINITION_VERSION>",
+  "display": { "label": "Abort" },
+  "inputs": {}
+}
+```
+
+For add, delete, and wiring procedures, see [editing-operations.md](../../editing-operations.md). Use the structure above for node-specific `inputs`.
+
+## Common Pattern — Error Handler
+
+```text
+HTTP Request
+  |-- default -> Process -> End
+  |-- error   -> Log Error (Script) -> Terminate
+```
+
+Wire the action node's implicit `error` source port directly to the handler. Have the Script log `$vars.httpCall.error`, then use Terminate to abort the flow. Do not put a Decision downstream to test for an error: a failing node has already faulted the flow before execution reaches it.
+
+Add this pattern only when requirements specify failure behavior. Without an error edge, failure faults the flow on its own, which is the correct default. Never set `inputs.errorHandlingEnabled: true` without the edge. See [file-format.md — Implicit error port on action nodes](../../../shared/file-format.md#implicit-error-port-on-action-nodes).
+
+## Debug
+
+| Error | Cause | Fix |
+| --- | --- | --- |
+| Terminate has outgoing edges | An edge was wired from Terminate | Remove it; Terminate has no output ports |
+| Workflow outputs missing | Terminate was reached where outputs were expected | Use End for paths that need output mapping; Terminate does not produce outputs |