@uipath/skills 1.195.0 → 1.196.0

package/skills/uipath-agents/references/lowcode/capabilities/inline-in-flow/inline-in-flow.md

@@ -126,25 +126,25 @@ features/
 resources/
 ```
 
-## Validate and Migrate Inline Agent
+## Refresh and Validate Inline Agent
 
 ```bash
+uip agent refresh "<FlowProjectDir>/<projectId>" --inline-in-flow --output json
 uip agent validate "<FlowProjectDir>/<projectId>" --inline-in-flow --output json
-uip agent migrate "<FlowProjectDir>/<projectId>" --inline-in-flow --output json
 ```
 
-`--inline-in-flow` skips `entry-points.json` and `project.uiproj` checks. Validate is read-only; migrate writes the migrated files and regenerates `.agent-builder/`.
+`--inline-in-flow` skips `entry-points.json` and `project.uiproj` checks. Refresh regenerates `entry-points.json` and `bindings_v2.json`; validate is read-only.
 
-For inline agents with external capabilities (tools, contexts, memory spaces, or escalations), pass `--bindings-target` to **`migrate`** after all flow graph edits:
+For inline agents with external capabilities (tools, contexts, memory spaces, or escalations), pass `--bindings-target` to **`refresh`** after all flow graph edits:
 
 ```bash
-uip agent migrate "<FlowProjectDir>/<projectId>" --inline-in-flow \
+uip agent refresh "<FlowProjectDir>/<projectId>" --inline-in-flow \
   --bindings-target "<FlowProjectDir>/bindings_v2.json" --output json
 ```
 
-`--bindings-target` propagates the inline agent's bindings (process, connection, index, memorySpace, app, etc.) into the flow project's `bindings_v2.json`. This is required for `uip solution resource refresh` to discover the bindings and create solution-level resource files. Never hand-edit `bindings_v2.json`.
+`--bindings-target` propagates the inline agent's bindings (process, connection, index, memorySpace, app, etc.) into the flow project's `bindings_v2.json`. This is required for `uip solution resources refresh` to discover the bindings and create solution-level resource files. Never hand-edit `bindings_v2.json`.
 
-> **Ordering constraint:** run the final `uip agent migrate --inline-in-flow --bindings-target …` after all flow graph edits are complete. The `uipath-maestro-flow` skill owns direct `.flow` authoring for the inline-agent node, capability-resource nodes, and edges; migrate last so the generated bindings land in the flow project's `bindings_v2.json` before `uip solution resource refresh`. See the [Walkthrough](#walkthrough--end-to-end) for the correct sequence.
+> **Ordering constraint:** run the final `uip agent refresh --inline-in-flow --bindings-target …` after all flow graph edits are complete. The `uipath-maestro-flow` skill owns direct `.flow` authoring for the inline-agent node, capability-resource nodes, and edges; refresh last so the generated bindings land in the flow project's `bindings_v2.json` before `uip solution resources refresh`. See the [Walkthrough](#walkthrough--end-to-end) for the correct sequence.
 
 ## Flow Wiring
 
@@ -152,7 +152,7 @@ After creating the inline agent, the flow needs a `uipath.agent.autonomous` node
 
 **Hand off to the `uipath-maestro-flow` skill for the actual node and edge authoring.** Per Critical Rule 16, this skill does not invoke flow operations directly. Tell the user:
 
-> The inline agent has been scaffolded at `<FlowProjectDir>/<projectId>/`. To wire it into the flow, use the `uipath-maestro-flow` skill — pass it `projectId = <uuid>` so it can add a `uipath.agent.autonomous` node with `inputs.source = <uuid>` and connect the input/success edges via direct `.flow` authoring. **After all flow graph edits are complete**, run `uip agent validate --inline-in-flow`, then `uip agent migrate --inline-in-flow`; for inline agents with external capabilities, include `--bindings-target <FlowProjectDir>/bindings_v2.json` on the migrate call.
+> The inline agent has been scaffolded at `<FlowProjectDir>/<projectId>/`. To wire it into the flow, use the `uipath-maestro-flow` skill — pass it `projectId = <uuid>` so it can add a `uipath.agent.autonomous` node with `inputs.source = <uuid>` and connect the input/success edges via direct `.flow` authoring. **After all flow graph edits are complete**, run `uip agent refresh --inline-in-flow`, then `uip agent validate --inline-in-flow`; for inline agents with external capabilities, include `--bindings-target <FlowProjectDir>/bindings_v2.json` on the refresh call.
 
 The node JSON shape that the flow skill must produce is documented in § Flow Node Structure below — keep it as a reference, not as a CLI walkthrough.
 
@@ -165,16 +165,16 @@ Inline-agent resources — `tool`, `context`, `escalation` — share one path co
 `<RES_UUID>` is a fresh UUID. It MUST match (a) the resource node's `inputs.source` in the flow and (b) the `id` field inside `resource.json`. The resource directory name is the UUID — never the human-readable resource name. Human-readable folder names are the standalone-agent convention; inline agents always use UUIDs.
 
 Resource body shape is identical to the standalone-agent docs — only the folder name differs:
-- Tools (`process` / `agent` / `api` / `processOrchestration`): [../process/process.md](../process/process.md) § Subtypes and § Tool resource.json Shape. Discovery is identical (`uip solution resource list` + `uip solution resource get`); subtype is selected by the `type` field.
+- Tools (`process` / `agent` / `api` / `processOrchestration`): [../process/process.md](../process/process.md) § Subtypes and § Tool resource.json Shape. Discovery is identical (`uip solution resources list` + `uip solution resources get`); subtype is selected by the `type` field.
 - Context index: [../context/index.md](../context/index.md) § Agent-Level Resource Shape.
 - Escalation: [../escalation/escalation.md](../escalation/escalation.md) § Agent-Level Resource.
 
 ### Tool-specific notes
 
-- **`location`**: Follows the same rule as standalone agents — set `"solution"` when the row from `uip solution resource list` has `Source: "Local"`, set `"external"` when `Source: "Remote"`. See [../process/process.md](../process/process.md) and [../../critical-rules.md](../../critical-rules.md) Rule 12.
-- **`properties.folderPath`**: Must be the **literal folder path from discovery** (e.g., `"Shared/Sales"`) — do **not** leave it empty. An empty `folderPath` prevents `uip solution resource refresh` from resolving the tool at runtime.
+- **`location`**: Follows the same rule as standalone agents — set `"solution"` when the row from `uip solution resources list` has `Source: "Local"`, set `"external"` when `Source: "Remote"`. See [../process/process.md](../process/process.md) and [../../critical-rules.md](../../critical-rules.md) Rule 12.
+- **`properties.folderPath`**: Must be the **literal folder path from discovery** (e.g., `"Shared/Sales"`) — do **not** leave it empty. An empty `folderPath` prevents `uip solution resources refresh` from resolving the tool at runtime.
 - **`inputSchema.properties`**: Must include `"guardrails": { "type": "array" }` alongside the tool arguments — the runtime expects it.
-- **All fields from the template in [../process/process.md](../process/process.md) are required** — especially `$resourceType: "tool"`, `guardrail`, `properties.processName`, `properties.exampleCalls`, `isEnabled`, and `argumentProperties`. A `resource.json` missing `$resourceType` will not be recognized by `uip agent validate` (the tool reports `"resources": 0`); `uip agent migrate` will then write an empty `bindings_v2.json`.
+- **All fields from the template in [../process/process.md](../process/process.md) are required** — especially `$resourceType: "tool"`, `guardrail`, `properties.processName`, `properties.exampleCalls`, `isEnabled`, and `argumentProperties`. A `resource.json` missing `$resourceType` will not be recognized by `uip agent validate` (the tool reports `"resources": 0`); `uip agent refresh` will then write an empty `bindings_v2.json`.
 
 ## Flow Node Structure
 
@@ -224,7 +224,7 @@ Resource body shape is identical to the standalone-agent docs — only the folde
 - `definitions[]` — The `uipath.agent.autonomous` definition copied from the flow registry supplies `model.serviceType: "Orchestrator.StartInlineAgentJob"`, BPMN type, version, and context. Do not copy those fields into the node instance.
 - No node instance `model` block — the inline-agent source lives at `inputs.source`.
 
-Resource nodes use the same `inputs.source` pattern as the autonomous agent — no instance `model` block. The `type` follows the per-kind patterns in § Resource nodes below — `uipath.agent.resource.tool.{process|agent|api|processorchestration}.<release-key>`, where `<release-key>` is the resource's release-key GUID returned by `uip solution resource list`:
+Resource nodes use the same `inputs.source` pattern as the autonomous agent — no instance `model` block. The `type` follows the per-kind patterns in § Resource nodes below — `uipath.agent.resource.tool.{process|agent|api|processorchestration}.<release-key>`, where `<release-key>` is the resource's release-key GUID returned by `uip solution resources list`:
 
 ```jsonc
 {
@@ -267,12 +267,13 @@ Resources are separate canvas nodes wired to the agent via artifact handle edges
 | Agent-as-tool | `uipath.agent.resource.tool.agent.<release-key>` |
 | API workflow | `uipath.agent.resource.tool.api.<release-key>` |
 | Process Orchestration | `uipath.agent.resource.tool.processorchestration.<release-key>` |
+| Built-in tool | `uipath.agent.resource.tool.builtin.<tool-name>` |
 | IS connector | `uipath.agent.resource.tool.connector` |
-| Semantic index | `uipath.agent.resource.context.index` |
+| Semantic index | `uipath.agent.resource.context.index.<index-name>.<index-id>` |
 | Escalation | `uipath.agent.resource.escalation` |
 | Memory space | `uipath.agent.resource.memory.*` canvas node, backed by `features/<FeatureName>/feature.json` from `uip agent memory` |
 
-`<release-key>` is the resource's release-key GUID from `uip solution resource list` (the row's `Key` field). The four process-tool kinds share the same registry-discovery flow and the same `resource.json` shape — only the prefix in front of `<release-key>` and the `type` field in `resource.json` differ. See [../process/process.md](../process/process.md) § Subtypes.
+`<release-key>` is the resource's release-key GUID from `uip solution resources list` (the row's `Key` field). The four process-tool kinds share the same registry-discovery flow and the same `resource.json` shape — only the prefix in front of `<release-key>` and the `type` field in `resource.json` differ. See [../process/process.md](../process/process.md) § Subtypes.
 
 ## Walkthrough — End-to-End
 
@@ -298,18 +299,18 @@ uip agent init "<FlowProjectDir>" --inline-in-flow --output json
 #    Do NOT run uip maestro flow commands from this skill —
 #    Critical Rule 16.
 
-# 6. Validate the inline agent (read-only check). MUST run AFTER flow
-#    graph edits (step 5).
-uip agent validate "<FlowProjectDir>/<projectId>" --inline-in-flow --output json
-
-# 7. Migrate — writes the migrated files, regenerates .agent-builder/,
+# 6. Refresh — regenerates entry-points.json and bindings_v2.json,
 #    and (with --bindings-target) propagates capability bindings into the flow
 #    project's bindings_v2.json so resource refresh can discover them.
-uip agent migrate "<FlowProjectDir>/<projectId>" --inline-in-flow \
+#    MUST run AFTER flow graph edits (step 5).
+uip agent refresh "<FlowProjectDir>/<projectId>" --inline-in-flow \
   --bindings-target "<FlowProjectDir>/bindings_v2.json" --output json
 
+# 7. Validate the inline agent (read-only check).
+uip agent validate "<FlowProjectDir>/<projectId>" --inline-in-flow --output json
+
 # 8. Refresh solution resources and upload
-uip solution resource refresh --output json
+uip solution resources refresh --output json
 ```
 
 ## What Happens at Pack Time
@@ -345,8 +346,8 @@ uipath.agent.resource.tool.agent.<release-key>                 ← Tool: agent
 uipath.agent.resource.tool.api.<release-key>                   ← Tool: API workflow
 uipath.agent.resource.tool.processorchestration.<release-key>  ← Tool: process orchestration
 uipath.agent.resource.tool.connector                           ← Tool: IS connector
-uipath.agent.resource.tool.builtin                             ← Tool: built-in
-uipath.agent.resource.context.index                            ← Context: semantic index
+uipath.agent.resource.tool.builtin.<tool-name>                 ← Tool: built-in
+uipath.agent.resource.context.index.<index-name>.<index-id>    ← Context: semantic index
 uipath.agent.resource.escalation                               ← Escalation: HITL
 uipath.agent.resource.memory.*                                 ← Memory space canvas node; feature file lives under features/
 ```
@@ -361,9 +362,9 @@ The execution is asynchronous. The flow pauses at the agent node and resumes whe
 
 See [../../critical-rules.md](../../critical-rules.md) Critical Rule 15. The skill explicitly defers flow authoring to `uipath-maestro-flow` — it does not invoke that skill automatically (Critical Rule 16).
 
-**Capability bindings must be propagated to the flow project's `bindings_v2.json`.** Only project-level bindings are scanned by `uip solution resource refresh`. Pass `--bindings-target <FlowProjectDir>/bindings_v2.json` to `uip agent migrate --inline-in-flow` — migrate is the command that writes the bindings. Without project-level propagation, Studio Web debug can fail because no solution-level resource file is created for the external capability.
+**Capability bindings must be propagated to the flow project's `bindings_v2.json`.** Only project-level bindings are scanned by `uip solution resources refresh`. Pass `--bindings-target <FlowProjectDir>/bindings_v2.json` to `uip agent refresh --inline-in-flow` — refresh is the command that writes the bindings. Without project-level propagation, Studio Web debug can fail because no solution-level resource file is created for the external capability.
 
-Run the final `uip agent migrate --inline-in-flow --bindings-target …` as the **last step** before `uip solution resource refresh`, after all flow graph edits are complete. See the [Walkthrough](#walkthrough--end-to-end) for the correct sequence.
+Run the final `uip agent refresh --inline-in-flow --bindings-target …` as the **last step** before `uip solution resources refresh`, after all flow graph edits are complete. See the [Walkthrough](#walkthrough--end-to-end) for the correct sequence.
 
 ## References
 

package/skills/uipath-agents/references/lowcode/capabilities/integration-service/integration-service.md

@@ -11,7 +11,7 @@ For Orchestrator process tools (RPA / agent / API / agentic process), see [../pr
 
 ## Key Difference from Orchestrator Tools
 
-IS tools use **connection** resources (not package/process resources) at the solution level. You only need to create the agent-level `resource.json` — solution-level files are auto-generated by `uip solution resource refresh`.
+IS tools use **connection** resources (not package/process resources) at the solution level. You only need to create the agent-level `resource.json` — solution-level files are auto-generated by `uip solution resources refresh`.
 
 IS tools differ structurally from Orchestrator-based tools:
 - `type` is `"integration"` (not `"process"`, `"agent"`, etc.)
@@ -199,16 +199,16 @@ The activity metadata's `fields.<name>.enum` already has this exact shape — co
 
 **Auto-generated.** Do not create them manually. After creating the agent-level `resource.json`:
 
-1. Run `uip agent validate` — read-only check.
-2. Run `uip agent migrate` — generates `bindings_v2.json` in the agent project directory.
-3. Run `uip solution resource refresh` from the solution root — auto-generates `resources/solution_folder/connection/{connectorKey}/` files and `debug_overwrites.json`.
+1. Run `uip agent refresh` — regenerates `entry-points.json` and `bindings_v2.json` in the agent project directory.
+2. Run `uip agent validate` — read-only check. Fails with `AgentValidationOutdated` if refresh is needed.
+3. Run `uip solution resources refresh` from the solution root — auto-generates `resources/solution_folder/connection/{connectorKey}/` files and `debug_overwrites.json`.
 
 **`location` and `folderPath`:**
 
 | `location` | `folderPath` | Meaning |
 |------------|-------------|---------|
 | `"solution"` | `"solution_folder"` | Resource is another project within this same solution. Creating this agent-level resource.json is sufficient. |
-| `"external"` | `"solution_folder"` | Resource is already deployed in Orchestrator, outside this solution. Write the agent-level resource.json, then run `uip agent validate` → `uip agent migrate` → `uip solution resource refresh` — refresh auto-generates the solution-level process declaration, package declaration, and `debug_overwrites.json` entry. |
+| `"external"` | `"solution_folder"` | Resource is already deployed in Orchestrator, outside this solution. Write the agent-level resource.json, then run `uip agent refresh` → `uip agent validate` → `uip solution resources refresh` — refresh auto-generates the solution-level process declaration, package declaration, and `debug_overwrites.json` entry. |
 
 ### Connection Definition (refresh fallback)
 
@@ -216,7 +216,7 @@ The activity metadata's `fields.<name>.enum` already has this exact shape — co
 
 Provisions an Integration Service connection as part of the solution. Required when an agent has an integration tool (`type: "integration"`). One per connector — all tools using the same connector share this connection resource.
 
-**Auto-generated:** Do not create these files manually. After creating the agent-level integration tool `resource.json`, run `uip agent validate` (read-only check), `uip agent migrate` (generates `bindings_v2.json`), then `uip solution resource refresh` (auto-generates connection resources and `debug_overwrites.json` from `bindings_v2.json`).
+**Auto-generated:** Do not create these files manually. After creating the agent-level integration tool `resource.json`, run `uip agent refresh` (regenerates `entry-points.json` and `bindings_v2.json`), then `uip agent validate` (read-only check), then `uip solution resources refresh` (auto-generates connection resources and `debug_overwrites.json` from `bindings_v2.json`).
 
 **Cross-reference:** The connection resource `key` matches the `solutionProperties.resourceKey` in integration tool resources that use this connector.
 
@@ -266,7 +266,7 @@ uip is connections list "<connector-key>" --output json
 
 Present connections to the user. Recommend the default enabled one but let the user confirm. Note the connection `Id`, `FolderKey`, `Name`. If no connection exists, prompt the user to create one via `uip is connections create "<connector-key>"`.
 
-This command also populates the local cache at `~/.uipath/cache/integrationservice/<connector-key>/connections.json` — used later by `uip solution resource refresh` to generate `debug_overwrites.json`. Running it is mandatory even when you already found the connection via `uip solution resource list --kind Connection`, because refresh reads from the cache this command writes.
+This command also populates the local cache at `~/.uipath/cache/integrationservice/<connector-key>/connections.json` — used later by `uip solution resources refresh` to generate `debug_overwrites.json`. Running it is mandatory even when you already found the connection via `uip solution resources list --kind Connection`, because refresh reads from the cache this command writes.
 
 ### Step 4 — Discover activities
 
@@ -307,19 +307,18 @@ If no `--connection-id` is available (e.g., the connector auto-provisions connec
 
 Build the `resource.json` from the metadata. See § Agent-Level Resource Shape above for the full template and field mapping.
 
-### Step 8 — Validate, migrate, and refresh solution resources
+### Step 8 — Refresh, validate, and refresh solution resources
 
 ```bash
+# Refresh — regenerates entry-points.json and bindings_v2.json.
+uip agent refresh "<AGENT_NAME>" --output json
+
 # Validate — read-only check.
 uip agent validate "<AGENT_NAME>" --output json
 
-# Migrate — generates bindings_v2.json in the agent project directory
-# and regenerates .agent-builder/.
-uip agent migrate "<AGENT_NAME>" --output json
-
 # Refresh solution resources — auto-generates solution-level connection
 # resources and debug_overwrites from bindings_v2.json
-uip solution resource refresh --output json
+uip solution resources refresh --output json
 ```
 
 At this point, the solution can be uploaded to Studio Web and tested:

package/skills/uipath-agents/references/lowcode/capabilities/mcp/mcp.md

@@ -0,0 +1,133 @@
+# MCP Server Tool
+
+Walkthrough for adding an **MCP (Model Context Protocol) server** as a resource on a low-code agent. An MCP server is a **cloud resource registered in AgentHub** and discoverable through Orchestrator's Resource Catalog — the agent *references* it (by slug + key), exactly like it references an Orchestrator process or app. The agent does **not** define the server's command/URL; that lives on the cloud server.
+
+The agent exposes a **selected subset** of the server's tools — carefully consider which tools the agent actually needs.
+
+## When to Use
+
+- The agent should call tools provided by an MCP server.
+- The MCP server is already registered in AgentHub (discover it below), or you register it first with `uip agenthub mcp create`.
+
+## Server Types
+
+MCP servers come in subtypes — `Command` (stdio, e.g. `npx`/`uvx`), `Remote` (SSE / streamable HTTP URL), `UiPath`, `Coded`, `Platform`. The subtype lives on the cloud server; the agent resource does not carry it. `uip solution resources refresh` reads it from the catalog and files the solution-level resource under the matching subtype folder.
+
+## Discovery
+
+### Step 1 — Scaffold solution + agent (if not already done)
+
+Scaffold per [../../project-lifecycle.md § End-to-End Example](../../project-lifecycle.md#end-to-end-example--new-standalone-agent).
+
+### Step 2 — Find the MCP server
+
+```bash
+uip solution resources list --kind mcpServer --source remote --output json
+```
+
+Each row carries what the agent resource needs:
+
+| `resource list` field | Use as |
+|---|---|
+| `Name` | the server's canonical name — use it for `slug`, the resource `name`, and the folder `resources/<name>/` (all match) |
+| `Key` | `solutionProperties.resourceKey` (the cloud server UUID) |
+| `Folder` | `folderPath` (the literal Orchestrator folder, e.g. `"Shared"`) — same convention as external process tools |
+| `Type` | informational — the subtype refresh files the resource under |
+
+If the server doesn't exist yet, register it: `uip agenthub mcp create command|remote|uipath|coded|platform … --output json` (see `uip agenthub mcp create --help`), then re-run the list.
+
+### Step 3 — Fetch the server's full tool list
+
+```bash
+uip solution resources get <Key> --solution-folder <SolutionDir> --output json
+```
+
+The response is `Data.Spec` with PascalCase fields. `Data.Spec.Tools[]` is the **complete** tool list the server exposes; each entry is `{ Name, Title, Description, InputSchema, OutputSchema }` where **`InputSchema` is an escaped JSON-Schema string** (parse it into an object before writing `availableTools`).
+
+## Tool Selection
+
+**Carefully consider which tools the agent needs.** From `Data.Spec.Tools` (the server's complete tool list), choose the tools relevant to the user's task and write that subset into `availableTools`. When the user's intent doesn't make the subset obvious, **ask the user which tools to include**. Adding more tools than the task needs bloats the agent's tool surface.
+
+## Agent-Level Resource Shape
+
+**Path:** `<AGENT_NAME>/resources/<ServerName>/resource.json`
+
+**Name the resource after the MCP server itself** — use the server's `Name` from `resource list` (e.g. `github-mcp`) verbatim for both the `name` field and the folder `resources/<name>/`; the two must match. Do not name it after the task or the tool subset — the selected tools go in `availableTools`, not in the resource name.
+
+Generate a fresh UUID for the top-level `id` (this is the agent-local resource id — distinct from `solutionProperties.resourceKey`, which is the cloud server's key).
+
+```jsonc
+{
+  "$resourceType": "mcp",
+  "id": "<uuid-v4>",                         // fresh agent-local id (NOT the cloud key)
+  "name": "github-mcp",                      // = the server's `Name`/slug; folder `resources/github-mcp/` matches
+  "description": "GitHub MCP server",        // non-empty
+  "slug": "github-mcp",                      // the server's canonical slug (= resource list `Name`)
+  "folderPath": "Shared",                    // the server's real folder from resource list `Folder` (external resource — same as a process tool)
+  "availableTools": [                         // the SELECTED subset, mapped from `resource get` Spec.Tools
+    {
+      "name": "create_issue",                // ← Tool.Name
+      "description": "Create a GitHub issue", // ← Tool.Description
+      "inputSchema": {                        // ← JSON.parse(Tool.InputSchema)
+        "type": "object",
+        "properties": { "repo": { "type": "string" }, "title": { "type": "string" } },
+        "required": ["repo", "title"]
+      },
+      "outputSchema": null                    // ← Tool.OutputSchema (usually null)
+    }
+  ],
+  "solutionProperties": { "resourceKey": "<cloud-server-key-uuid>" }  // from resource list `Key`
+}
+```
+
+Required fields (validated by `uip agent validate`): `$resourceType`, `id`, `name`, `description`, `slug`, `folderPath`, `availableTools` (array; each tool needs `name`, `description`, `inputSchema`), `solutionProperties.resourceKey`. Extra fields sometimes present (`toolsConfiguration`, per-tool `argumentProperties`) are optional and ignored by validation.
+
+## Walkthrough
+
+### Step 4 — Write the agent-level resource.json
+
+Use the shape above, with `availableTools` = your selected subset.
+
+### Step 5 — Refresh, validate, and refresh solution resources
+
+```bash
+# Refresh — regenerates entry-points.json + bindings_v2.json (writes the mcpServer binding).
+uip agent refresh "<AGENT_NAME>" --output json
+
+# Validate — strict, read-only. Confirm Status: "Valid" and Resources count includes the MCP resource.
+uip agent validate "<AGENT_NAME>" --output json
+
+# Refresh solution resources — resolves the mcpServer binding against AgentHub and writes
+# the solution-level reference file + debug_overwrites entry.
+uip solution resources refresh --output json
+```
+
+After `uip solution resources refresh`, confirm the solution-level reference was created:
+
+```text
+resources/solution_folder/<McpServerKind>/<Type>/<slug>.json   # e.g. .../McpServer/Command/github-mcp.json
+```
+
+It is a **reference** (`key` = the cloud server UUID, full `spec` incl. command/URL + tools pulled from AgentHub), placed under `solution_folder` with a `debug_overwrites.json` entry mapping it to its real cloud folder — so the binding is overridable per environment.
+
+### Step 6 — Upload (with user consent)
+
+```bash
+uip solution upload . --output json
+```
+
+`uip solution upload` bundles the solution and uploads it in one pass — there is no separate `uip solution bundle` step.
+
+## Gotchas
+
+- **`availableTools` is a curated subset** — include the tools the task needs; ask the user when the relevant set is unclear.
+- **`inputSchema` must be a JSON object**, not the escaped string `resource get` returns — parse `Tool.InputSchema` first.
+- **`id` ≠ `resourceKey`.** `id` is a fresh agent-local UUID; `solutionProperties.resourceKey` is the cloud server's `Key` from `resource list`.
+- **`folderPath` is the server's real folder** (the literal `Folder` from `resource list`, e.g. `"Shared"`) — like an external process tool; see [../../agent-definition.md](../../agent-definition.md) § folderPath semantics for the binding mechanism. MCP-specific: the binding resolves by `slug` + `folderPath` (slugs are unique only *within* a folder), so author the real folder, **not** `"solution_folder"`. An existing reference solution may show `"solution_folder"` because it was resolved by `resourceKey` instead — CLI `refresh` resolves by `slug`+`folderPath`.
+- **`uip agent validate` is strict read-only** — it does not write; run `uip agent refresh` first to generate derived files.
+
+## References
+
+- [../../agent-definition.md](../../agent-definition.md) § Resources Convention
+- [../../project-lifecycle.md](../../project-lifecycle.md) § Resource Discovery
+- [../process/process.md](../process/process.md) — the analogous cloud-referenced tool (process) and its discovery pattern

package/skills/uipath-agents/references/lowcode/capabilities/memory/memory.md

@@ -4,10 +4,10 @@ Use this when a low-code agent needs an attached UiPath memory space for dynamic
 
 ## Critical Rules
 
-1. **Use `uip agent memory` for memory features.** Do not hand-author `features/{Name}/feature.json` unless recovering from a broken project. The CLI updates both the feature file and `.agent-builder/agent.json`.
-2. **`uip agent memory add` attaches an existing memory space; it does not create the platform memory space.** Always attempt `uip solution resource list --kind MemorySpace` discovery before attaching, even when the user supplied an exact memory space name and folder. Treat provided values as search inputs and fallback values only if discovery is blocked by auth or connectivity.
+1. **Use `uip agent memory` for memory features.** Do not hand-author `features/{Name}/feature.json` unless recovering from a broken project. The CLI updates the feature file; run `uip agent refresh` afterwards to regenerate derived files.
+2. **`uip agent memory add` attaches an existing memory space; it does not create the platform memory space.** Always attempt `uip solution resources list --kind MemorySpace` discovery before attaching, even when the user supplied an exact memory space name and folder. Treat provided values as search inputs and fallback values only if discovery is blocked by auth or connectivity.
 3. **Use folder paths, not folder keys.** `--folder-path` must be the literal folder path where the memory space exists, such as `Shared` or `Shared/Sales`.
-4. **Validate, migrate, and refresh after memory changes.** Memory bindings are generated during `uip agent migrate`; do not edit `bindings_v2.json` directly. In a solution, always attempt `uip solution resource refresh --output json` from the solution root after migration so the generated `memorySpace` binding is imported into solution resources.
+4. **Refresh, validate, and solution-refresh after memory changes.** Memory bindings are generated during `uip agent refresh`; do not edit `bindings_v2.json` directly. In a solution, always attempt `uip solution resources refresh --output json` from the solution root after refresh so the generated `memorySpace` binding is imported into solution resources.
 5. **Seed only non-sensitive examples.** Memory items become agent project configuration. Do not store secrets, credentials, or raw PII as seed items.
 
 ## Workflow
@@ -17,7 +17,7 @@ Use this when a low-code agent needs an attached UiPath memory space for dynamic
 Always attempt discovery first, even when the user already provided the memory space name and folder. Use the provided name as the search term:
 
 ```bash
-uip solution resource list --source remote --kind MemorySpace --search "<MEMORY_SPACE_NAME>" --output json
+uip solution resources list --source remote --kind MemorySpace --search "<MEMORY_SPACE_NAME>" --output json
 ```
 
 Use the row's `Name` as `--memory-space` and `Folder` as `--folder-path`. If discovery fails because the local session is not authenticated or the network is unavailable, continue only when the user already provided both the memory space name and folder path; use those provided values and report that discovery was attempted.
@@ -25,7 +25,7 @@ Use the row's `Name` as `--memory-space` and `Folder` as `--folder-path`. If dis
 If the space is external to the solution and should be tracked as a solution resource:
 
 ```bash
-uip solution resource add \
+uip solution resources add \
   --source remote \
   --kind MemorySpace \
   --name "<MEMORY_SPACE_NAME>" \
@@ -93,12 +93,12 @@ Episodic memory items require `--feedback-id`; use the feedback ID for the conve
 ```bash
 uip agent memory list --path "<AGENT_PROJECT_DIR>" --output json
 uip agent memory item list SupportRecall --path "<AGENT_PROJECT_DIR>" --output json
+uip agent refresh "<AGENT_PROJECT_DIR>" --output json
 uip agent validate "<AGENT_PROJECT_DIR>" --output json
-uip agent migrate "<AGENT_PROJECT_DIR>" --output json
-uip solution resource refresh --output json
+uip solution resources refresh --output json
 ```
 
-After migration, inspect `<AGENT_PROJECT_DIR>/bindings_v2.json` only to verify that a `memorySpace` binding exists. Do not edit it. Run `uip solution resource refresh` from the solution root so the solution resource catalogue sees the memory binding. Do not skip refresh because the memory space name/folder were provided, because `bindings_v2.json` looks correct, or because publish/deploy is out of scope. If refresh fails due authentication, leave the generated files intact and report the failed refresh command.
+After refresh, inspect `<AGENT_PROJECT_DIR>/bindings_v2.json` only to verify that a `memorySpace` binding exists. Do not edit it. Run `uip solution resources refresh` from the solution root so the solution resource catalogue sees the memory binding. Do not skip refresh because the memory space name/folder were provided, because `bindings_v2.json` looks correct, or because publish/deploy is out of scope. If refresh fails due authentication, leave the generated files intact and report the failed refresh command.
 
 ## Remove
 
@@ -183,4 +183,4 @@ Expected shape, for review only:
 | `Invalid memory-type value` | Unsupported type | Use `episodic`, `escalation`, `0`, or `1` |
 | `Invalid metadata JSON` | Metadata is malformed or not an object | Pass a valid JSON object, e.g. `'{"source":"seed"}'` |
 | `Memory space "<name>" matches by memory space name` | More than one feature references the same memory space name | Pass `--folder-path`, use the feature name, or use the feature ID |
-| No `memorySpace` binding after migration | Migrate was not run after the memory edit | Run `uip agent migrate "<AGENT_PROJECT_DIR>" --output json` |
+| No `memorySpace` binding after refresh | Refresh was not run after the memory edit | Run `uip agent refresh "<AGENT_PROJECT_DIR>" --output json` |

package/skills/uipath-agents/references/lowcode/capabilities/process/process.md

@@ -31,13 +31,13 @@ Two supported invocations — pick one based on where you're looking:
 **Local (in-solution):**
 
 ```bash
-uip solution resource list --source local --output json
+uip solution resources list --source local --output json
 ```
 
 **Remote (Orchestrator / RCS):**
 
 ```bash
-uip solution resource list --source remote --kind Process --search "<NAME>" --output json
+uip solution resources list --source remote --kind Process --search "<NAME>" --output json
 ```
 
 > **`--kind` and `--search` only work with `--source remote`.** With `--source local` or `--source all` (default), both flags must be omitted — list everything and filter `.Data[]` client-side by `Kind` and `Name`.
@@ -68,7 +68,7 @@ When the same `Name` repeats in one folder, pick by `Key`.
 ### 2. Get the resource configuration
 
 ```bash
-uip solution resource get <KEY> --output json
+uip solution resources get <KEY> --output json
 ```
 
 Response wrapper: `{Result, Code: "ResourceConfiguration", Data: {...}}`. `Data` is the solution-level resource declaration.
@@ -93,7 +93,7 @@ If both V2 and raw schemas are absent, the deployed process truly has no argumen
 #### Optional: `--include-dependencies`
 
 ```bash
-uip solution resource get <KEY> --include-dependencies --output json
+uip solution resources get <KEY> --include-dependencies --output json
 ```
 
 Wrapper changes to `Code: "ResourceConfigurations"` with `Data.resources[]` containing the process plus each dependency (the package, `kind: "package"`).
@@ -146,11 +146,11 @@ Wrapper changes to `Code: "ResourceConfigurations"` with `Data.resources[]` cont
 
 ## Solution-Level Files
 
-**Auto-generated by `uip agent migrate` + `uip solution resource refresh`.** After creating the agent-level `resource.json`:
+**Auto-generated by `uip agent refresh` + `uip solution resources refresh`.** After creating the agent-level `resource.json`:
 
-1. Run `uip agent validate` — read-only check. Reports `MigrationPending: true` if migration is needed.
-2. Run `uip agent migrate` — emits `bindings_v2.json` with a `resource: "process"` binding.
-3. Run `uip solution resource refresh` — for each Process binding, looks up the matching resource (in RCS for remote, in the solution for local) and writes:
+1. Run `uip agent refresh` — regenerates `entry-points.json` and `bindings_v2.json` with a `resource: "process"` binding.
+2. Run `uip agent validate` — read-only check. Fails with `AgentValidationOutdated` if refresh is needed.
+3. Run `uip solution resources refresh` — for each Process binding, looks up the matching resource (in RCS for remote, in the solution for local) and writes:
    - `resources/solution_folder/process/<type_dir>/<ToolName>.json` (declaration)
    - `resources/solution_folder/package/<PackageName>.json` (package declaration)
    - an entry in `userProfile/<userId>/debug_overwrites.json` with real `folderKey`, `folderFullyQualifiedName`, and `folderPath` so Studio Web can resolve the process at runtime. An entry missing `folderFullyQualifiedName` or `folderPath` will cause "Could not find process for tool '<name>'" — refresh from current uipcli populates both correctly.
@@ -175,16 +175,16 @@ For in-solution agents already registered with the parent solution — auto-regi
 
 # 2. Discover the process
 # Remote: --kind / --search supported server-side.
-uip solution resource list --source remote --kind Process --search "<NAME>" --output json
+uip solution resources list --source remote --kind Process --search "<NAME>" --output json
 # Local: --kind and --search NOT supported — list, then filter .Data[] client-side.
-uip solution resource list --source local --output json
+uip solution resources list --source local --output json
 # Parse .Data[]. Each entry: Source, Key, Name, Kind, Type (lowercase), Folder, FolderKey.
 # Source: "Local" → location: "solution". "Remote" → location: "external".
 # Use Key as referenceKey, Name as processName, Type for the agent-level type,
 # Folder as properties.folderPath.
 
 # 3. Pull the full configuration
-uip solution resource get <KEY> --output json
+uip solution resources get <KEY> --output json
 # Parse .Data.spec for:
 #   inputArgumentsSchemaV2 / outputArgumentsSchemaV2  → JSON Schema strings (Agent / API / Agentic)
 #   inputArgumentsSchema   / outputArgumentsSchema    → raw .NET arrays (RPA)
@@ -196,17 +196,17 @@ Then create the agent-level resource file at `<AGENT_NAME>/resources/<TOOL_NAME>
 ```bash
 # 4. Configure agent.json (system prompt, model, schemas)
 
-# 5. Validate — read-only check.
-uip agent validate "<AGENT_NAME>" --output json
+# 5. Refresh — regenerates entry-points.json and bindings_v2.json.
+uip agent refresh "<AGENT_NAME>" --output json
 
-# 6. Migrate — generates bindings_v2.json and regenerates .agent-builder/.
-uip agent migrate "<AGENT_NAME>" --output json
+# 6. Validate — read-only check.
+uip agent validate "<AGENT_NAME>" --output json
 
 # 7. Refresh solution resources — resolves each Process binding and produces
 #    `resources/solution_folder/process/<type>/<Name>.json`,
 #    `resources/solution_folder/package/<PackageName>.json`, and an entry in
 #    `userProfile/<userId>/debug_overwrites.json`. No hand-authoring needed.
-uip solution resource refresh --output json
+uip solution resources refresh --output json
 
 # 8. Bundle + upload
 uip solution bundle . -d ./dist --output json
@@ -222,8 +222,9 @@ When two agent projects in the same solution call each other (parent-tool topolo
 # 2. Add a second agent. When run from inside the solution directory,
 #    `uip agent init` auto-registers the project with the parent `.uipx`
 #    (confirm via `Data.SolutionRegistration.Status` in the response).
-#    `uip solution project add` is the fallback only when registration
-#    was `Skipped` or `Failed`.
+#    `uip solution project add` is the fallback when registration was
+#    `NotInSolution` / `Skipped` / `Failed` (not for `OptedOut`, which means
+#    `--skip-solution-registration` was passed and the skip was intentional).
 uip agent init "ToolAgent" --output json
 # (fallback) uip solution project add "ToolAgent" --output json
 # Either path creates resources/solution_folder/package/ToolAgent.json and
@@ -231,19 +232,19 @@ uip agent init "ToolAgent" --output json
 
 # 3. From ParentAgent, add ToolAgent as a tool — discovery via the unified flow.
 # `--source local` accepts neither --kind nor --search; list then filter client-side.
-uip solution resource list --source local --output json
+uip solution resources list --source local --output json
 # Pick the row with Kind="Process" and Name="ToolAgent", then:
-uip solution resource get <KEY> --output json
+uip solution resources get <KEY> --output json
 # Then create ParentAgent/resources/ToolAgent/resource.json with location: "solution".
 
-# 4. Validate and migrate both agents, then bundle/upload as usual.
+# 4. Refresh and validate both agents, then bundle/upload as usual.
+uip agent refresh  ParentAgent --output json
 uip agent validate ParentAgent --output json
-uip agent migrate  ParentAgent --output json
+uip agent refresh  ToolAgent --output json
 uip agent validate ToolAgent --output json
-uip agent migrate  ToolAgent --output json
 ```
 
-UUID cross-references between `SolutionStorage.Projects[].ProjectId`, `package/<ToolAgent>.json.projectKey`, and `process/agent/<ToolAgent>.json.projectKey` are auto-managed by project registration (`uip agent init` auto-registration, or the `uip solution project add` fallback) and `uip agent migrate` — do not hand-edit. See [../../solution-resources.md](../../solution-resources.md) § UUID Cross-References.
+UUID cross-references between `SolutionStorage.Projects[].ProjectId`, `package/<ToolAgent>.json.projectKey`, and `process/agent/<ToolAgent>.json.projectKey` are auto-managed by project registration (`uip agent init` auto-registration, or the `uip solution project add` fallback) and `uip agent refresh` — do not hand-edit. See [../../solution-resources.md](../../solution-resources.md) § UUID Cross-References.
 
 ## Gotchas
 

package/skills/uipath-agents/references/lowcode/capabilities/process/solution-files.md

@@ -1,10 +1,10 @@
 # Solution-Level Files for External Process Tools — Hand-Authoring Reference
 
-When `uip solution resource refresh` cannot produce solution-level files (offline, missing RCS match, custom deployment), hand-author them using the templates below. For the standard auto-generated path, see [process.md](process.md).
+When `uip solution resources refresh` cannot produce solution-level files (offline, missing RCS match, custom deployment), hand-author them using the templates below. For the standard auto-generated path, see [process.md](process.md).
 
-It also documents the Releases API + `GetPackageEntryPointsV2` + JWT decoding extraction path — used when `uip solution resource get` is unavailable (older `uip` builds, RCS unreachable, custom deployments). For the standard CLI-driven extraction, see [process.md § Discovery](process.md#discovery).
+It also documents the Releases API + `GetPackageEntryPointsV2` + JWT decoding extraction path — used when `uip solution resources get` is unavailable (older `uip` builds, RCS unreachable, custom deployments). For the standard CLI-driven extraction, see [process.md § Discovery](process.md#discovery).
 
-> **`folders[].fullyQualifiedName` carries the literal `Folder`** (e.g., `"Shared"`, `"Shared/Sales"`) returned by `uip solution resource list` — the same value the agent-level `resource.json` writes into `properties.folderPath` and that `bindings_v2.json` propagates. Templates show `<Folder>` as the placeholder; examples show `"Shared"` as a concrete value. Auto-generated declarations for **solution-internal projects** (created when the agent project is registered with the solution — by `uip agent init` auto-registration or by the `uip solution project add` fallback) keep `"solution_folder"` instead — they have no fixed Orchestrator folder until deploy. See [../../critical-rules.md](../../critical-rules.md) Rule 11.
+> **`folders[].fullyQualifiedName` carries the literal `Folder`** (e.g., `"Shared"`, `"Shared/Sales"`) returned by `uip solution resources list` — the same value the agent-level `resource.json` writes into `properties.folderPath` and that `bindings_v2.json` propagates. Templates show `<Folder>` as the placeholder; examples show `"Shared"` as a concrete value. Auto-generated declarations for **solution-internal projects** (created when the agent project is registered with the solution — by `uip agent init` auto-registration or by the `uip solution project add` fallback) keep `"solution_folder"` instead — they have no fixed Orchestrator folder until deploy. See [../../critical-rules.md](../../critical-rules.md) Rule 11.
 
 ## Directory Structure
 
@@ -445,7 +445,7 @@ Maps `solution_folder` to the actual Orchestrator folder so Studio Web can resol
           "overwrite": {
             "resourceKey": "<release-key-guid>",
             "resourceName": "<ToolName>",
-            "folderKey": "<folder-key-guid>",            // FolderKey from `uip solution resource list --kind Process`
+            "folderKey": "<folder-key-guid>",            // FolderKey from `uip solution resources list --kind Process`
             "folderFullyQualifiedName": "<folder-path>", // Folder from the same (e.g., "Shared/MyFolder")
             "folderPath": "<parent-key>.<folder-key>",   // If folder has parent: "parentKey.folderKey". If no parent: just "folderKey"
             "type": "Reference",
@@ -464,14 +464,14 @@ For the generic debug_overwrites shape (capability-agnostic), see [../../solutio
 
 ## How to Get the Values
 
-> **Fallback path.** When `uip solution resource get` is available, use it instead — see [process.md § Discovery](process.md#discovery). The steps below are for older `uip` builds, RCS-unreachable environments, or custom deployments where the CLI cannot supply the full configuration.
+> **Fallback path.** When `uip solution resources get` is available, use it instead — see [process.md § Discovery](process.md#discovery). The steps below are for older `uip` builds, RCS-unreachable environments, or custom deployments where the CLI cannot supply the full configuration.
 
 > **SECURITY: Never read `~/.uipath/.auth` directly** — the access token must not appear in Claude's context. Always use a `bash -c` wrapper that sources the auth file and makes the API call in a single shell invocation, so Claude only sees the API response.
 
 ### Step 1: Discover the process and its folder
 
 ```bash
-uip solution resource list --kind Process --source remote --search "<NAME>" --output json
+uip solution resources list --kind Process --source remote --search "<NAME>" --output json
 ```
 
 Returns, for each match: