@uipath/skills 1.199.0-preview.106 → 1.199.0-preview.171

package/assets/uip-catalog-snapshot.json

@@ -233,8 +233,6 @@
     "agenthub mcp update",
     "agenthub mcp-tools",
     "agenthub mcp-tools candidates",
-    "agenthub mcp-tools create-is-activity",
-    "agenthub mcp-tools create-raw",
     "agenthub mcp-tools create-resource",
     "agenthub mcp-tools delete",
     "agenthub mcp-tools disable",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/skills",
-  "version": "1.199.0-preview.106",
+  "version": "1.199.0-preview.171",
   "description": "UiPath agent skills for Claude Code, Codex, Cursor, Copilot, Gemini and OpenCode — RPA, UI automation, UI testing, coded agents/apps/workflows, and troubleshooting. Distributed as the UiPath Claude Code plugin.",
   "author": {
     "name": "UiPath"

package/skills/uipath-mcp-servers/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: uipath-mcp-servers
-description: "UiPath AgentHub MCP server registration + tool authoring via `uip agenthub mcp` (six server types: uipath / coded / command / remote / platform / swagger) and `uip agenthub mcp-tools` (three tool kinds: is-activity / resource / raw on `uipath`-type servers). For Integration Service activity authoring→load `references/is-activity-workflow.md`. For Python MCP servers / coded-agent integration→uipath-agents. For raw IS CLI→uipath-platform."
+description: "UiPath AgentHub MCP server registration + resource-tool authoring via `uip agenthub mcp` (six server types: uipath / coded / command / remote / platform / swagger) and `uip agenthub mcp-tools` on `uipath`-type servers. For Python MCP servers / coded-agent integration→uipath-agents."
 allowed-tools: Bash, Read, Write, Edit, Glob, Grep, AskUserQuestion
 ---
 
@@ -13,9 +13,8 @@ Register AgentHub MCP servers via `uip agenthub mcp`. Author tools on `uipath`-t
 ## When to Use This Skill
 
 - Create / update / delete / refresh / list / get an AgentHub MCP server (any of: `uipath`, `coded`, `command`, `remote`, `swagger`, `platform`).
-- Author / list / get / enable / disable / delete tools on a `uipath`-type server (`is-activity`, `resource`, `raw`).
-- **For `is-activity` tools (Integration Service connector activities), load [references/is-activity-workflow.md](references/is-activity-workflow.md) end-to-end before authoring.** It owns the Pre-flight, cascade, `designTimeLookups`, `ActivityMetadata` schema, and connector-specific troubleshooting.
-- Skip: Python MCP server implementation (FastMCP / `@uipath/mcp`) → `uipath-agents`. Raw IS CLI outside MCP tooling → `uipath-platform`.
+- Author resource tools on a `uipath`-type server; list / get / enable / disable / delete its tools.
+- Skip: Python MCP server implementation (FastMCP / `@uipath/mcp`) → `uipath-agents`.
 
 ## Trust the CLI
 
@@ -23,8 +22,8 @@ The CLI is the source of truth for shapes and flags. Use it instead of guessing:
 
 - `uip agenthub mcp create <type> --print-schema --output json` — payload shape for any server type.
 - `uip agenthub mcp template <type> --output json` — ready-to-edit `--file` skeleton.
-- `uip agenthub mcp-tools template <kind> --output json` — tool payload skeleton (is-activity / resource / raw).
-- `uip agenthub mcp-tools candidates --category <kind> --output json` — discover bindable targets. `<kind>` ∈ `automation | agent | agentic-process | api-workflow | is-activity`.
+- `uip agenthub mcp-tools template resource --output json` — resource-tool payload skeleton.
+- `uip agenthub mcp-tools candidates --category <kind> --output json` — discover bindable targets. `<kind>` ∈ `automation | agent | agentic-process | api-workflow`.
 - `--output-filter <JMESPath>` on every command — extract specific fields without walking JSON by hand (e.g. `--output-filter "Data.items[].slug" --output plain`).
 - `--dry-run` on every mutating call — resolve and inspect the body before POST. Note: `--dry-run` skips some server-side validation, so a clean dry-run is not a guaranteed real POST.
 
@@ -41,19 +40,17 @@ These are the things the CLI does not advertise in `--help`.
 4. **`refresh-tools` behavior depends on server type.**
    - `coded` / `command` — async, returns HTTP 202 + runtime id. Surface the runtime id; never claim refreshed before a follow-up `mcp-tools list --mcp <slug>` confirms.
    - `remote` / `platform` / `swagger` — sync, returns 200 after a synchronous fetch+upsert.
-   - `uipath` / `selfhosted` — rejected locally; tools are manually authored via `mcp-tools create-*`. CLI emits a `NextCommand` hint to author instead.
+   - `uipath` / `selfhosted` — rejected locally; resource tools are manually authored via `mcp-tools create-resource`. CLI emits a `NextCommand` hint to author instead.
 
 5. **`mcp delete` looks up by slug, not GUID.** Passing a GUID returns 404.
 
-6. **For any `is-activity` tool, read [references/is-activity-workflow.md](references/is-activity-workflow.md) end-to-end before any CLI call.** It owns the cascade-asking gate, the action-triggered platform-IS reads, the `ActivityMetadata` schema, and the `inputSchema` / `designTimeLookups` rules. IS metadata authored from memory passes `--dry-run` but fails at runtime — do not skip the reference. `Reason: IsActivityNotAvailable` from ANY is-activity verb → STOP immediately: no further is-activity calls (no create attempt "to confirm" — the error covers every verb), no `--force` without explicit user approval; the gate follows the payload — an IS-activity payload (`type: 1` + `processType: Api`) via `create-raw` / `create-resource` / `update --file`/`--body` is gated identically; offer `resource` / `raw` instead (genuinely different kinds, not the same payload re-verbed — reference §Availability).
-
 ## Server Types
 
 `uip agenthub mcp create` takes six type subcommands. All share `--name <display>`, `--slug <kebab>`, `--description`, `--version`, `--file`/`--body`/`--print-schema`, `--dry-run`, `--folder-path`/`--folder-key`, `--tenant`, `--login-validity`. The differentiating flag picks the integration shape:
 
 | Type | Differentiating flag | When to use | Tool surface |
 |------|---------------------|-------------|--------------|
-| `uipath`   | _(none)_              | AgentHub-hosted server you'll fill with `mcp-tools create-*`. | Authored via `uip agenthub mcp-tools create-*`. `refresh-tools` rejected. <!-- uip-check-skip --> |
+| `uipath`   | _(none)_              | AgentHub-hosted server you'll fill with resource tools. | Authored via `uip agenthub mcp-tools create-resource`. `refresh-tools` rejected. |
 | `coded`    | `--process-key <key>` (+ `--folder-key` for the process) | Wrap an existing coded-agent process (published to Orchestrator) as an MCP server. | Discovered via `refresh-tools` (async 202). |
 | `command`  | `--command <cmd>` + `--arg <arg>` (repeatable) + `--env <k=v>` (repeatable) | Spawn a local subprocess as an MCP server. | Discovered via `refresh-tools` (async 202). |
 | `remote`   | `--uri <url>` + `--header <k=v>` (repeatable) + `--use-relay` | Point at an existing HTTP MCP server. Bearer/header values can be Orchestrator asset references; `AssetReferenceSubstitutor` resolves them at runtime via the caller's token + folder context. Do NOT invent a credential-store syntax. | Discovered via `refresh-tools` (sync 200). |
@@ -66,15 +63,13 @@ Headers/auth on `remote` and `swagger` are payload fields, not scalar flags. Rea
 
 `mcp template <type>` also accepts `process-assistant` and `selfhosted` — these have templates but NO `create` subcommand (backend enum only; skip).
 
-## Tool Kinds (`uipath`-type servers only)
+## Resource Tools (`uipath`-type servers only)
 
-`uip agenthub mcp-tools create-{is-activity | resource | raw}`. Shared flags: `--mcp <slug>` (parent server), `--name`, `--description`, `--target-identifier <guid>` / `--target-name <name>` (resolve target via RCS — only for non-`activity` categories), `--folder-key <guid>` / `--folder-path <name>` (MCP server folder context), `--target-folder-key <guid>` / `--target-folder-path <name>` (any kind — the target's folder — IS connection / Orchestrator resource / raw payload target — when it differs from the server's; resolves to the tool's `targetFolderKey`; never both; omit to default to the candidate's folder (`--target-name`) or the server folder; the explicit flag wins, including over a `--file`/`--body` payload field), `--category`, `--input-schema`, `--output-schema`, `--metadata`, `--continue-on-error` (default) / `--fail-fast`, `--file`/`--body`, `--dry-run`. Differ in metadata shape, discovery path, and validation strictness.
+Run `uip agenthub mcp-tools create-resource`. Flags: `--mcp <slug>` (parent server), `--name`, `--description`, `--target-identifier <guid>` / `--target-name <name>` (resolve target via RCS), `--folder-key <guid>` / `--folder-path <name>` (MCP server folder context), `--target-folder-key <guid>` / `--target-folder-path <name>` (the Orchestrator resource's folder when it differs from the server's; resolves to the tool's `targetFolderKey`; never both; omit to default to the candidate's folder (`--target-name`) or the server folder; the explicit flag wins, including over a `--file`/`--body` payload field), `--category`, `--input-schema`, `--output-schema`, `--metadata`, `--continue-on-error` (default) / `--fail-fast`, `--file`/`--body`, `--dry-run`.
 
 | Kind | Discovery | Validation | When to use |
 |------|-----------|------------|-------------|
-| `is-activity` | `mcp-tools candidates --category is-activity` + `is resources describe` | Connector schema | Wrap an Integration Service connector activity as an MCP tool. **Load [references/is-activity-workflow.md](references/is-activity-workflow.md) end-to-end** — extra Critical Rules, Pre-flight, `ActivityMetadata` schema, and IS-specific troubleshooting apply. Rolling out: unavailable environments fail with `Reason: IsActivityNotAvailable` — follow the reference's §Availability (stop; offer `resource` / `raw`). |
 | `resource`    | `mcp-tools candidates --category <kind>` (kind ∈ `automation` / `agent` / `agentic-process` / `api-workflow`) | Resource schema | Bind an Orchestrator resource. Pass `--target-identifier <resource-id>`. Read metadata shape from `mcp-tools template resource --output json`. `candidates` is tenant-wide — each item carries its `folder {key, name}`; present the folder alongside the name when the user picks. `--target-name` lookup searches the server folder by default; resource in a different folder → pass `--target-folder-path` / `--target-folder-key` (scopes the lookup AND sets the tool's `targetFolderKey`); with `--target-identifier`, pass the same flags when the resource's folder differs from the server's. |
-| `raw`         | None | None | Free-form JSON tool — caller owns correctness end-to-end. No discovery, no schema validation, no reference-value labeling. Read the skeleton from `mcp-tools template raw --output json`. |
 
 Stringify `--metadata` / `--input-schema` / `--output-schema` as scalars (not `--file`). Build each JSON in a file and pass it as `--metadata "$(jq -c . metadata.json)"` (likewise input/output schema) — do **not** assemble multi-KB JSON inline in the command. Pass `--output-schema "{}"` when the underlying target has no response fields — empty string is rejected with `Unexpected end of JSON input`.
 
@@ -89,5 +84,3 @@ Other `mcp-tools` verbs (`list --mcp <slug>`, `get`, `enable`, `disable`, `delet
 - **Slug rejected with validation error** — backend enforces `^[a-z0-9-]+$`, length 3-50 (Critical Rule 1).
 - **`mcp delete <guid>` returns 404** — `mcp delete` looks up by slug, not GUID (Critical Rule 5).
 - **`refresh-tools` returns 202 with a runtime id** — `coded` / `command` refreshes are async (Critical Rule 4). Surface the runtime id; verify via follow-up `mcp-tools list --mcp <slug>`.
-
-Tool-kind-specific troubleshooting lives with the workflow that owns it — IS-activity troubleshooting is in [references/is-activity-workflow.md](references/is-activity-workflow.md).

package/skills/uipath-planner/SKILL.md

@@ -138,7 +138,7 @@ High-level view of what each specialist owns. **Do not describe internal flows o
 | `uipath-platform` | Auth (`uip login`), Orchestrator (folders, processes, jobs, machines, users, roles), resources (assets, queues, storage buckets + bucket files, libraries, webhooks, triggers), Integration Service (connectors, connections, activities, IS triggers), Data Fabric entities/records/files/choice-sets (`uip df`), traces, licensing | Yes (auth hub) | **Yes** — for non-solution single packages and Orchestrator-side post-deploy ops |
 | `uipath-ixp` | Document Understanding / IXP — extraction from semi-structured documents (invoices, forms): taxonomy, model, classify / extract / validate. Standalone project, or the extraction step a primary consumes | Yes (`uip login`) | **Partial** — model publish/tag via `uip ixp`; consumed by the host project |
 | `uipath-connector-builder` | Integration Service **custom connector** authoring (REST+JSON) on disk via `uip is connectors builder` — build a connector when the catalog has none for a required integration (needed by API Workflows / Maestro / Agents; RPA can call the API directly instead) | Yes (`uip login`) | **Yes** — import/publish is deployment (`uip is connectors`) |
-| `uipath-mcp-servers` | UiPath AgentHub MCP server registration (6 types: `uipath`, `coded`, `command`, `remote`, `swagger`, `platform`) and tool authoring on `uipath`-type servers (3 kinds: `is-activity`, `resource`, `raw`). Wraps IS connector activities, Orchestrator resources, external HTTP MCP endpoints, OpenAPI specs, published coded agents, local subprocess commands, or first-party UiPath services as MCP tools. NOT for FastMCP / Python `mcp` SDK work. | Yes (`uip login`) | **Yes** — registration is deployment (posts directly to AgentHub) |
+| `uipath-mcp-servers` | UiPath AgentHub MCP server registration (6 types: `uipath`, `coded`, `command`, `remote`, `swagger`, `platform`) and resource-tool authoring on `uipath`-type servers (`automation`, `agent`, `agentic-process`, `api-workflow`). Wraps Orchestrator resources, external HTTP MCP endpoints, OpenAPI specs, published coded agents, local subprocess commands, or first-party UiPath services as MCP tools. NOT for FastMCP / Python `mcp` SDK work. | Yes (`uip login`) | **Yes** — registration is deployment (posts directly to AgentHub) |
 | `uipath-solution` | `uip solution` lifecycle (init, pack, publish, deploy, activate) for `.uipx` solutions. Runs as the final skill in PDD-driven flows (deploy of `.uipx` solutions). | Yes (`uip login`) | **Yes** — for multi-project Solution (`.uipx`) deploys |
 
 ## Reference Navigation

package/skills/uipath-planner/references/multi-skill-patterns-guide.md

@@ -92,7 +92,7 @@ Orchestrator deploy of the wrapping `.uipx` solution requires `uipath-solution`.
 
 ## Pattern 6 — Build an AgentHub MCP server
 
-**When it applies:** the request is to register an AgentHub MCP server that wraps a coded agent or uses Orchestrator-asset-backed auth that does not exist yet. Pure `uipath-mcp-servers` work — `uipath` / `command` / `platform` servers, `remote`/`swagger` with auth assets already in place, or any `is-activity` tool authoring against existing IS connections — is single-skill; go straight to `uipath-mcp-servers`.
+**When it applies:** the request is to register an AgentHub MCP server that wraps a coded agent or uses Orchestrator-asset-backed auth that does not exist yet. Pure `uipath-mcp-servers` work — `uipath` servers with resource tools, `command` / `platform` servers, or `remote` / `swagger` servers with auth assets already in place — is single-skill; go straight to `uipath-mcp-servers`.
 
 Wrapping a not-yet-built coded agent (server type `coded`):
 
@@ -108,8 +108,6 @@ Orchestrator assets needed for `remote` / `swagger` Bearer / header substitution
 2. uipath-mcp-servers → register the server with asset-substituted headers
 ```
 
-Missing IS connections are **not** a `uipath-platform` prereq — IS connections are created interactively in the Integration Service UI via OAuth, not by the CLI.
-
 ## Pattern routing for PDD-driven lane
 
 When deriving tasks from an SDD, the planner picks a pattern based on the SDD's project list:

package/version-manifest.json

@@ -1,5 +1,5 @@
 {
   "schemaVersion": 2,
-  "skillsVersion": "1.199.0-preview.106",
+  "skillsVersion": "1.199.0-preview.171",
   "targetCli": "^1.199.0"
 }

package/skills/uipath-mcp-servers/references/is-activity-workflow.md

@@ -1,168 +0,0 @@
-# IS-Activity Tool Authoring
-
-Wrap an Integration Service connector activity as an MCP tool via `uip agenthub mcp-tools create-is-activity`. Discovery verb is `uip is resources run` / `describe` (pre-rename `execute` → use `run`).
-
-**Division of labor.** The metadata-*discovery* workflow — `describe`, reference resolution, cascade (`-f`), scope filtering, static-value labeling — lives in the platform IS references below; this file does not restate it. This file owns the MCP-tool layer: turning discovered metadata into the `create-is-activity` payload (`ActivityMetadata`, `inputSchema`, `outputSchema`). **Do not author IS metadata from memory** — a `designTimeLookups` / `-f` / `reference` shape that "looks right from a rule" still gets the wrong shape per connector and fails at runtime after passing `--dry-run`. Read the platform section at the action-trigger below even when confident.
-
-## Availability (rollout gate)
-
-IS-activity MCP tools are rolling out: live on alpha/staging; NOT yet on `cloud.uipath.com` (prod — server-side feature flag per tenant). CLI enforces this: `candidates --category is-activity` and `create-is-activity` fail fast with `Reason: IsActivityNotAvailable` on unavailable hosts. The gate follows the payload, not just the verb: `create-resource` / `create-raw` / `update` carrying an IS-activity payload (`type: 1` + `processType: "Api"`, via `--file`/`--body`) are gated identically — there is no smuggling route. On that error: STOP — do not retry, do not run `create-is-activity` to "confirm" the gate (the error already covers every is-activity verb), do not re-author the same payload through `create-raw` / `update`. Tell the user the feature is not yet available on this environment; offer `resource` / `raw` tools instead — meaning a genuinely different tool kind (Orchestrator resource binding / non-IS raw payload), NOT the IS-activity payload under another verb. Re-run with `--force` (accepted on every gated verb) ONLY when the user confirms the tenant is enrolled in the rollout. CLI versions without the gate: the create succeeds but yields a dead tool (hidden in UI, not invocable) — apply the same rule manually before authoring: base URL is `cloud.uipath.com` → stop and ask.
-
-## Platform IS references — read by action
-
-In `../../uipath-platform/references/integration-service/`. Each is small. Do NOT read all upfront — before performing each action, read the named section first. The blind spots are unknown-unknowns, so the trigger is the action, not your sense of certainty.
-
-| Before this action | First read |
-|---|---|
-| `uip is connections list <key>` for the first time | `connections.md` §`Folder Scoping` (pass `--all-folders`) |
-| `is resources describe ... -f <parent>=<value>` (any cascade re-run) — **mandatory, incl. curated activities you "know" (Jira `curated_create_issue`)** | `resources.md` §`Parent-Field-Driven Custom Fields` (`-f` shape, `--operation` requirement, `--action` rule, merge semantics) |
-| A `staticValues.<bucket>.<field>` whose describe field has a `.reference` block | `reference-resolution.md` §`Static Reference-Value Labeling` (`designTimeLookups` format + cascade-scope edge cases) |
-| An `inputSchema.properties.<field>` whose `.reference.path` contains `{otherField}` | `reference-resolution.md` §`Field Dependency Chains` (resolve parent first) |
-| An `inputSchema.properties.<field>` whose `.reference.filterPattern` contains `{filter}` | `reference-resolution.md` §`Search References` |
-| Resolving a reference where `run list` returns `scope: null` AND `scope.type: "PROJECT"` rows | `reference-resolution.md` §`Scope Filtering` |
-| Diagnosing a `describe` server-side failure | `resources.md` §`Describe Failures` |
-| Final gate before `create-is-activity --dry-run` | `reference-resolution.md` §`Validate Required Fields Before Executing` |
-
-## Critical rules (extend SKILL.md)
-
-1. **Discover before authoring.** `candidates --category is-activity` resolves connector + activity; `is resources describe` pulls field metadata. Compose `metadata` / `inputSchema` / `outputSchema` from the describe response, never from memory — every connector + operation has its own shape.
-2. **Enumerate connections across ALL folders, then pick.** Discovery: `uip is connections list <connector-key> --all-folders --output json` — one call spanning every folder you can see. Mandatory on EVERY connections listing — including verification when the user already named a connection or folder. Never call the bare form: without `--all-folders` the call silently scopes to the current context and may return empty; `--all-folders` is mutually exclusive with `--folder` / `--folder-key`. Capture each row's folder — the user picks connection + folder together (Pre-flight 1). Pass `--target-identifier <connection-guid>`; `targetFolderKey` then defaults to the MCP server folder. Connection in a different folder → set it explicitly with `--target-folder-path <name>` / `--target-folder-key <guid>` (mirrors `--folder-path` / `--folder-key`, never both); the cross-folder guard allows an explicit target folder. Neither target-folder flag passed and `Reason: CrossFolderConnection` → pick from `Data.candidates`. (`connections.md` §`Folder Scoping` / §`Selecting a Connection`)
-3. **Cascade api-type ObjectActions.** Before the first `-f` cascade re-run you **MUST read `resources.md` §`Parent-Field-Driven Custom Fields`** — the pointers in this rule are a map, not a substitute. Knowing a connector's cascade fields from memory (e.g. Jira `curated_create_issue` = `project.key` + `issuetype.id`) does NOT exempt you: the `-f` shape, `--operation` requirement, `--action` rule, and merge semantics vary per connector and change over time; a shape that "looks right" passes `--dry-run` and fails at runtime. Then: `describe <key> <objectName> --connection-id <id> --operation <op>`; if `requestFields` is short for the operation, re-run with `-f <parent>=<value>` (repeatable). Omit `--action` for Jira `curated_create_issue` Create (passing it → `No api-type ObjectAction matched`); pass `--action` only when describe reports multiple matches. Cascade examples: Jira `curated_create_issue`, Salesforce `query_records`, Dataservice V3.
-4. **Baked static reference values need `designTimeLookups`.** Every `staticValues.<bucket>.<field>` (any bucket — `field` / `query` / `header` / `path`) whose describe field has a `.reference` block MUST emit `designTimeMetadata.designTimeLookups[<dotted-field>] = "<displayName> - <value>"`. Applies to `requestFields[]` and `parameters[]`; NOT to runtime / enum fields — labeling renders only for baked values. (`reference-resolution.md` §`Static Reference-Value Labeling`)
-5. **Stringify `metadata` / `inputSchema` / `outputSchema` as scalars** — SDK types them `string | null`. Build each in a file and pass `--metadata "$(jq -c . metadata.json)"`; do not assemble multi-KB JSON inline, and do not mix `--file` with scalar options (`ConflictingInput`). `--output-schema "{}"` when the activity has no `responseFields` (empty string → `Unexpected end of JSON input`).
-6. **Ask — don't guess — when a value drives discovery.** Cascade `-f` parents, a search-reference `{filter}`, a dependency-chain parent, or a required reference with no user hint: STOP and ask, even in autonomous mode. **No autonomous fallback exists.** If the user defers ("Other" / "you decide" / silence), re-ask in plain text — do NOT fall back to free runtime, a guessed default, or silently skipping the tool. Bounded set (2–4 candidates) → `AskUserQuestion` (do not add "Other"; it is auto-appended; <2 options errors). Unbounded set (dozens+) → plain text showing the top 5–10 candidates by a real attribute plus the exact format you need (`"<project key> + <issue type>"`). Never filter an unbounded `run list` with a guessed `JMESPath` name — a miss returns `[]` with no signal.
-
-## Reference fields — the 3-way choice
-
-For every `requestFields[name].reference` or `parameters[name].reference` (`reference-resolution.md` §`Reference Fields`), run `uip is resources run list <connector> <reference.objectName> --connection-id <id> --output json`, then pick per field:
-
-- **(a) Bake** — `staticValues.<bucket>.<field> = <value>` + a `designTimeLookups` entry (Rule 4). When one value applies to every call (user named it).
-- **(b) Constrained runtime** — `inputSchema.properties.<field> = {type: string, enum: [<discovered values>]}`. When the set is bounded (≤ 20–50), stable, known now. No lookup needed.
-- **(c) Free runtime** (default) — `inputSchema.properties.<field> = {type: string}`, no enum. When the set is large / volatile (IDs, free text, search inputs). The `description` is the prompt the consuming LLM reads: noun phrase + format (e.g. `"IANA timezone like 'UTC'"`) + omission behavior + constraints.
-
-Cascade roots and search references with no user-supplied filter = **hard ask** (Rule 6) — no "pick first" / "most-recent" default. Non-cascade required references default to (c) in autonomous mode; use (b) only when the set is genuinely small and stable.
-
-## Pre-flight (walk before drafting `--metadata`)
-
-0. **Scope.** Restate server slug, folder, exact tool list (one bullet per `<connector> · <activity> · <op>`), baked statics. Folder: if unnamed, `uip or folders list --output json` → `Shared` (org-default) or `<email>'s workspace` (personal needs `--folder-key <guid>`). Run `mcp-tools list --mcp <slug> --folder-path <name>` first — same name + connector + objectName exists → ask update vs add-new.
-1. **Connection** — Rule 2: enumerate with `--all-folders` FIRST. Exploring every folder is mandatory before presenting any choice — never ask off a single-folder view. Then ask which connection + folder to use: present name / owner / folder per row, never UUIDs (`connections.md` §`Selecting a Connection`); 2–4 rows → `AskUserQuestion`, more → plain-text top list. Confirm even on a single match. A connection in ANY folder is usable (Rule 2's target-folder flags). Zero across all folders → surface a create-connection hint and STOP.
-2. **Activity disambiguation.** `candidates --category is-activity --connector <key>` returns ≥2 overlapping entries (`send_message_to_channel` vs `_to_user`) → ASK. GET tie-break: `Get…` / `Find…` without an id → `List`; `Get … by …` or path `{id}`/`{key}` → `Retrieve`; unsure → describe without `--operation`, present `Data.availableOperations[]`.
-3. **Reference fields** — the 3-way choice above, per field.
-4. **Required scalar with no enum / reference / description** → STOP, ask (e.g. Slack `UsersByEmail.By`). Do not bake a guess.
-
-Multi-tool builds ("server with tools for X and Y"): re-walk Pre-flight + the command steps per tool — by tool 3 you drift toward tool 1's model.
-
-## `ActivityMetadata` (the object to stringify into `--metadata`)
-
-```jsonc
-{
-  "connector":   { "key": "<connector-key>" },              // from candidates
-  "object": {
-    "path":        "<availableOperations[chosen].path — e.g. /issue/{issueKey}/comment/{commentId}>",
-    "objectName":  "<the describe argument, e.g. issue_comment>",
-    "method":      "<GET|POST|PATCH|PUT|DELETE — from availableOperations[chosen].method>",
-    "contentType": "application/json"
-  },
-  "mapping": {
-    "path":   ["issueKey", "commentId"],   // property names filling {placeholder} tokens in object.path
-    "query":  ["maxResults", "startAt"],   // parameters[i] where .type === "query"
-    "header": [],                           // parameters[i] where .type === "header"
-    "field":  []                            // body fields (typically requestFields[])
-  },
-  "staticValues": {
-    "query":  { /* field-name: literal value the LLM cannot override */ },
-    "header": { },
-    "path":   { },
-    "field":  { /* body fields the LLM cannot override */ }
-  },
-  "designTimeMetadata": {
-    "designTimeLookups": {
-      // one entry per staticValues.* field whose describe field has .reference
-      // value format: "<displayName> - <baked-value>"  e.g. "fields.project.key": "Orchestrator - OR"
-      // see Critical Rule 4
-    },
-    "manageProperties": []
-  },
-  "metadataVersion": 1
-}
-```
-
-`staticValues` holds only values the LLM cannot override (`processType`, baked enum choices, baked reference IDs); runtime values belong in `inputSchema.properties`. Emit flat dotted keys (`"fields.project.key": "OR"`); the FE may persist them nested on save — both round-trip through `ParameterMappingService`'s four-bucket iteration (`Query` / `Path` / `Header` / `Field`).
-
-`inputSchema.properties` = `requestFields ∪ parameters` not covered by `staticValues`. Per entry: name = `parameters[i].name` / `requestFields[j].name`; `title` = `displayName ?? name`; `description`; `type` from `dataType` / field shape; add to `required[]` when `.required === true`; honor `enum` / `.reference` (the 3-way choice). Curated activities often have empty `requestFields[]` before cascade — `parameters` is then the input source. Set `additionalProperties: false`. `mapping.path` must list every `{token}` in `object.path` by property name (CLI validates client-side).
-
-`outputSchema` is a real JSON Schema built from `Data.responseFields` (walk like `inputSchema.properties`). Do not ship `{"type":"object","additionalProperties":true}`. `"{}"` only when the activity genuinely has no response body.
-
-## Workflow (commands)
-
-```bash
-# 0 — folders (once per machine); personal workspace needs --folder-key, not --folder-path
-uip or folders list --output json
-
-# 1 — confirm / create the `uipath`-type server (slug ^[a-z0-9-]+$, len 3-50)
-uip agenthub mcp list --folder-path <folder> --output-filter "Data.items[].slug" --output json
-# server folder unknown → uip agenthub mcp list --all-folders --output json (then use its folder on every later call)
-uip agenthub mcp create uipath --name "<display>" --slug <slug> --folder-path <folder> --output json
-
-# 2 — connector key + activity (vendor name ≠ connector key; e.g. Slack → uipath-salesforce-slack)
-uip agenthub mcp-tools candidates --category is-activity --name <vendor> --output json
-uip agenthub mcp-tools candidates --category is-activity --connector <key> --output json
-# Read Data.items[].{connectorKey, objectName, methodName, displayName}. Multi-candidate → Pre-flight 2.
-
-# 3 — describe: operations, then field metadata  (cascade/reference mechanics → platform refs)
-uip is resources describe <key> <objectName> --connection-id <id> --output json            # Data.availableOperations[]
-uip is resources describe <key> <objectName> --connection-id <id> --operation <op> --output json
-# requestFields[] (body), parameters[] (path/query/header), responseFields[] (output).
-# Short requestFields → curated: cascade with -f.  [READ FIRST, mandatory even if you know the fields: resources.md §Parent-Field-Driven Custom Fields]
-
-# 4 — connections across ALL folders (mandatory even when the user named the connection; folder may differ from server — step 7 --target-folder-*)   [READ: connections.md §Selecting a Connection + §Folder Scoping]
-uip is connections list <connector-key> --all-folders --output json   # never the bare form; present name/owner/folder; user picks connection + folder
-
-# 5 — label every baked static reference value  [READ: reference-resolution.md §Static Reference-Value Labeling]
-uip is resources run list <connector> <reference.objectName> --connection-id <id> --output json
-
-# 6 — dry-run preview (skips some server-side checks; can pass while the real POST fails)
-uip agenthub mcp-tools create-is-activity ... --dry-run --output json   # inspect Data.resolved.{metadata,inputSchema,outputSchema}
-
-# 7 — create
-uip agenthub mcp-tools create-is-activity \
-  --mcp <slug> --name "<tool name>" --description "<1-4000 chars; shown in AgentHub UI>" \
-  --folder-path "<server folder>" --target-identifier <connection-guid> \
-  --target-folder-path "<connection folder; omit to default to server folder>" \
-  --metadata "$(jq -c . metadata.json)" --input-schema "$(jq -c . input-schema.json)" \
-  --output-schema "$(jq -c . output-schema.json)" --output json   # Data.id = created tool ID
-
-# 8 — verify (do NOT claim done before this passes)
-uip agenthub mcp-tools list --mcp <slug> --folder-path <folder> --output json
-# Confirm id/name/description/mcpName. High-value tools: smoke-test via `uip is resources run <verb>`.
-```
-
-Connection in a different folder than the server → add `--target-folder-path <name>` (or `--target-folder-key <guid>`, never both); resolves to `targetFolderKey`. Omit both → defaults to the server folder.
-
-Update (metadata/schemas changed) — scalars only, `--output-schema "{}"` for no response body:
-
-```bash
-uip agenthub mcp-tools update <tool-id> --mcp <slug> --folder-path "<folder>" \
-  --metadata "$(jq -c . metadata.json)" --input-schema "$(jq -c . input-schema.json)" \
-  --output-schema "$(jq -c . output-schema.json)" --output json
-```
-
-Delete: `uip agenthub mcp-tools delete <tool-id> --mcp <slug> --folder-key <guid> --output json`.
-Skeleton for `--file`: `uip agenthub mcp-tools template is-activity --output json`.
-
-## IS-Activity Troubleshooting
-
-- **`Reason: IsActivityNotAvailable`** — environment not in the is-activity rollout (see §Availability). Gate follows the payload: also fires on `create-resource` / `create-raw` / `update` carrying an IS-activity payload. Stop; offer `resource` / `raw` (a genuinely different kind, not the same payload re-verbed); `--force` only for rollout-enrolled tenants.
-- **HTTP 400, no detail** — re-run `--dry-run`; CLI surfaces ASP.NET ProblemDetails as an `Errors` field of per-field failures.
-- **404 at runtime** — `metadata.mapping.path` missing a `{token}` from `object.path`. List every placeholder and retry.
-- **`Reason: CrossFolderConnection`** — connection in a different folder than the server. Pass `--target-folder-path <name>` / `--target-folder-key <guid>` for the connection's folder (guard allows an explicit target folder), or pick a `Data.candidates` entry via `--target-identifier <guid>`, or move the connection / server.
-- **`Operation 'X' not found. Available: <Y>`** — curated activity exposes only `Y`. Re-run `describe` without `--operation`, pick from `Data.availableOperations[]`.
-- **`No api-type ObjectAction matched for fields [...]`** — `-f` set matches no registered action, or `--action` was passed when it should be omitted (Jira `curated_create_issue` Create). Drop `--action` first; else inspect `connectorMethodInfo.design.actions[]` / `objectActions[]` for required `-f` shapes.
-- **Form renders raw scalar (`OR`, `3`) instead of a labeled value** — `designTimeLookups[<field>]` missing (Rule 4 / Step 5), then `mcp-tools update <tool-id>`.
-- **`ConflictingInput: Use exactly one of --file, --body, or scalar options.`** — pass schemas as scalars, not `--file`.
-- **`Unexpected end of JSON input` on `--output-schema`** — pass `"{}"` for no-response-body activities.
-- **`connections list <key>` empty / misses a known connection** — `--all-folders` missing; without it the call silently scopes to the current context. Re-run with `--all-folders` (mutually exclusive with `--folder` / `--folder-key`). Cross-folder is allowed — reference it via `--target-folder-path` / `--target-folder-key` (Rule 2); do NOT move the connection to the server folder. (`connections.md` §`Folder Scoping`)
-- **`Reason: TargetFolderMismatch` / `AmbiguousConnection`** — `--target-name` + explicit `--target-folder-*`: zero / multiple connections for the connector in the requested folder. Pick from `Data.candidates`, re-run with `--target-identifier <conn-guid>`.
-- **403 Forbidden at runtime** — connection scope mismatch; re-authorize via `uip is connections edit <id>` with broader scopes (`connections.md` §`Scope-Related Errors`).
-
-For generic AgentHub-MCP issues (slug regex, folder context, refresh-tools async/sync, `mcp delete` lookup), see SKILL.md §Troubleshooting.