@uipath/skills 1.199.0 → 1.200.0

package/skills/uipath-platform/references/data-fabric/entity-schema.md

@@ -83,8 +83,6 @@ Very large text. Contract differs from `MULTILINE_TEXT`:
 2. **List/query reads return a size marker, not content.** `records list` / `records query` return a string starting `HasValue=true Length=N` (live form: `"HasValue=true Length=20000 — call Get Entity Record By Id activity to retrieve content"`); only `records get <entity-id> <record-id>` returns the full value. Read + write-back rules in [records-query.md → MULTILINE_MAX fields](records-query.md#multiline_max-fields--marker-vs-full-content).
 3. **On a 400 from `entities create` / `addFields` naming the type**, surface the error verbatim — do NOT retry or silently substitute `MULTILINE_TEXT` (Rule 18).
 
-Needs `@uipath/data-fabric-tool` `1.198.0+` (see data-fabric.md → Tool Version Requirements).
-
 ```bash
 uip df entities create "Documents" \
   --body '{"fields":[{"fieldName":"Title","type":"STRING","isRequired":true},{"fieldName":"Body","type":"MULTILINE_MAX"}]}' \
@@ -97,13 +95,17 @@ uip df entities create "Documents" \
 
 ### Name Validation
 
-Both entity names and field names must:
+Entity names must:
 - Start with a letter (`[a-zA-Z]`)
 - Contain only letters, digits, and underscores (`[a-zA-Z0-9_]`)
 - Be 3–100 characters long
-- **Not** be a C# or VB reserved keyword — full list, error string (`"cannot be a reserved word in C# or VB"` / `RESERVED_LANGUAGE_KEYWORDS`), and rename examples are in **data-fabric.md Rule 4**. SQL keywords (e.g. `Status`, `Order`, `Key`) are NOT rejected — idiomatic field names are fine.
+- **Not** be a C# or VB reserved keyword. The CLI also rejects some SQL-reserved words such as `Order`, while ordinary names such as `Status` and `Key` are accepted. Surface the actual validation error and ask for a domain-specific rename; do not maintain a speculative local keyword list. See **data-fabric.md Rule 4**.
+
+Field names follow the same length and starting-letter rules but may contain **letters and digits only** (`[a-zA-Z0-9]`); underscores are rejected. A field name also cannot equal its entity name, ignoring case.
 
-**Reserved field names** (will error if used): `Id`, `CreatedBy`, `CreateTime`, `UpdatedBy`, `UpdateTime`
+**Reserved field names** (case-insensitive): `Id`, `CreatedBy`, `CreateTime`, `UpdatedBy`, `UpdateTime`, `RecordOwner`
+
+Within one create/add batch, field names and effective display names must each be unique ignoring case. An entity supports at most 10 `MULTILINE_MAX` fields.
 
 ### All Field Options
 
@@ -124,10 +126,10 @@ Both entity names and field names must:
 
 | Option | Type | Default | Notes |
 |--------|------|---------|-------|
-| `fieldName` | string | required | 3–100 chars, starts with letter, `[a-zA-Z0-9_]` |
+| `fieldName` | string | required | 3–100 chars, starts with letter, letters and digits only |
 | `type` | `EntityFieldDataType` | `STRING` | See type table above |
-| `displayName` | string | fieldName | Human-readable label |
-| `description` | string | `""` | Optional description |
+| `displayName` | string | fieldName | Human-readable label, max 128 chars |
+| `description` | string | `""` | Optional description, max 512 chars |
 | `isRequired` | boolean | `false` | Field must have a value on insert |
 | `isUnique` | boolean | `false` | Value must be unique across all records |
 | `isRbacEnabled` | boolean | `false` | Role-based access control on this field |
@@ -137,7 +139,7 @@ Both entity names and field names must:
 
 ### Advanced Field Constraints
 
-Accepted on `entities create` and on `addFields` / `updateFields` in `entities update`. Each constraint applies only to specific types — passing one to an unsupported type errors with *"Field '<name>' of type <TYPE> does not accept <option>"*. `minValue` must be strictly less than `maxValue`.
+Accepted on `entities create` and on `addFields` / `updateFields` in `entities update`. Each constraint applies only to specific types — passing one to an unsupported type errors with *"Field '<name>' of type <TYPE> does not accept <option>"*. `minValue` must be less than or equal to `maxValue`.
 
 | Constraint | Allowed type | Range |
 |------------|--------------|-------|
@@ -184,71 +186,31 @@ uip df entities update <entity-id> \
 
 - `referenceEntityId` — UUID of the target entity. Get it from `entities list --native-only` (the `Id` column). Target must exist and be native (no federated targets).
 - `referenceFieldId` — UUID of the **display field** on the target entity. This is a user-visible product decision — it controls which target field renders in pickers, lists, and the Data Fabric UI when the relationship is shown. **Always confirm with the user** which field to display (`Name`, `Email`, `Title`, etc.) — do NOT silently default to the target's `Id` UUID just because it exists. List the target's candidate display fields from `entities get <target-entity-id>` (`Fields[].Name`/`DisplayName` for human-readable scalar fields) and raise an `AskUserQuestion` dropdown if more than one fits. The stored record value is **always the target record's UUID `Id`** regardless of which field is bound here — `referenceFieldId` is purely the join-and-render hint. Auto Mode does NOT waive this confirmation: rendering choices are user-domain, not technical defaults.
-- `referenceFolderKey` — applies to **`RELATIONSHIP` and `FILE` fields only**. Required whenever the target is folder-scoped, including when the target lives in the **same folder** as the parent. Without it, a folder-scoped parent referencing a folder-scoped target fails with *"Cannot create relationship field from folder-level entity ('<parent>') to tenant-level entity ('')"* — a misleading error caused by the missing per-field scope hint. Omit only when (a) both parent and target are tenant-level, or (b) the target is a tenant-level system entity (e.g. `EntityAttachment` for FILE, `User` for `CreatedBy`/`UpdatedBy`). **`CHOICE_SET_*` fields do NOT need `referenceFolderKey`** — the backend resolves the choice-set's folder server-side from `choiceSetId` alone. **Folder-scoped parent fields cannot reference tenant-level user-authored targets** — and vice versa. See [Cross-folder references](#cross-folder-references) for the full matrix.
+- `referenceFolderKey` — applies to **`RELATIONSHIP` only**. Pass it whenever the target is folder-scoped, including when it is in the same folder as the parent. Omit it for tenant-level targets. `CHOICE_SET_*` resolves scope from `choiceSetId`; `FILE` is auto-wired and takes no reference fields. See [Cross-folder references](#cross-folder-references).
 - The field lives on the *child* (many-side) and points at the *parent* (one-side) — no reverse field on the parent.
 - Record value is **always the target record's UUID `Id`**, regardless of which field's UUID was passed as `referenceFieldId` (it controls the join, not the stored value). If the user supplies an email / label, resolve it first via `records query` on the target entity.
 - `FILE` fields do NOT take reference fields — server auto-wires. See [FILE Fields](#file-fields).
 - Cue phrases that signal a `RELATIONSHIP` (never substitute `STRING`/`UUID` — **data-fabric.md Rule 12**): *"each order has a Customer"*, *"each report has a Supplier"*, *"each issue belongs to a Project"*.
 - If the user didn't name a target entity OR the named one doesn't exist, follow the **pick-or-create flow in data-fabric.md Rule 13** — list candidates via `entities list --native-only`, ask, create only with approval.
 
-```bash
-# 1. Discover target entity + field UUIDs
-uip df entities list --native-only --output json   # → find Customer entity's Id
-uip df entities get <customer-entity-id> --output json   # → find Id field's Id under Fields[]
-
-# 2. Resolve email → record Id, then insert
-uip df records query <customer-entity-id> \
-  --body '{"filterGroup":{"logicalOperator":0,"queryFilters":[{"fieldName":"Email","operator":"=","value":"alice@example.com"}]},"selectedFields":["Id"]}' \
-  --output json
-uip df records insert <child-entity-id> --body '{"customerId":"<resolved-uuid>","amount":250}' --output json
-```
-
 ### Cross-folder references
 
-`RELATIONSHIP`, `FILE`, and `CHOICE_SET_*` field bindings require the parent and the target to share **scope class** (both tenant, or both folder — possibly different folders). **Crossing the tenant ↔ folder boundary is not allowed.** A folder-scoped entity cannot bind a tenant-level user-authored choice set / target entity; a tenant-level entity cannot bind a folder-scoped target. Folder ↔ folder works (same or different).
+`RELATIONSHIP` and `CHOICE_SET_*` bindings require the parent and target to share **scope class**: both tenant-level or both folder-scoped. Folder-to-folder works across different folders; crossing the tenant/folder boundary does not. `FILE` is excluded because the server always binds it to the platform-managed attachment entity.
 
 **Per-field `referenceFolderKey` differs by field type:**
 
-- **`RELATIONSHIP` / `FILE`** — pass `referenceFolderKey` whenever the target is folder-scoped, **including same-folder bindings**. The server uses it to resolve the target's scope; omitting it on a folder→folder binding produces the misleading *"Cannot create relationship field from folder-level entity ('<parent>') to tenant-level entity ('')"* error (the absence is interpreted as "target is tenant" → trips the cross-scope block).
+- **`RELATIONSHIP`** — pass `referenceFolderKey` whenever the target is folder-scoped, including same-folder bindings. Omitting it makes the server treat the target as tenant-level and reject the binding.
 - **`CHOICE_SET_SINGLE` / `CHOICE_SET_MULTIPLE`** — do **NOT** pass `referenceFolderKey` at the API level. The backend resolves the choice-set's folder server-side from `choiceSetId` alone. Passing it is unnecessary and may be rejected.
 
-| Parent scope | Target scope | Allowed? | `referenceFolderKey` for `RELATIONSHIP` / `FILE` | `referenceFolderKey` for `CHOICE_SET_*` |
+| Parent scope | Target scope | Allowed? | `referenceFolderKey` for `RELATIONSHIP` | `referenceFolderKey` for `CHOICE_SET_*` |
 |---|---|---|---|---|
 | Tenant | Tenant | ✅ | Omit | Omit |
 | Folder A | Folder A (same folder) | ✅ | `<folder-A-guid>` — required, even same-folder | Omit (server resolves from `choiceSetId`) |
 | Folder A | Folder B (different folder) | ✅ | `<folder-B-guid>` | Omit (server resolves from `choiceSetId`) |
 | Folder | Tenant user-authored entity / choice set | ❌ | n/a — not supported | n/a — not supported |
-| Folder | Tenant **system** entity (`EntityAttachment`, `User`) | ✅ | Omit — platform-managed | n/a — no system choice sets |
 | Tenant | Folder | ❌ | n/a — not supported | n/a — not supported |
 
-> **Same-folder gotcha for `RELATIONSHIP` / `FILE` only** — even though both entities live in the same folder, omitting `referenceFolderKey` makes the server unable to resolve the target's scope and the create errors out with *"Cannot create relationship field from folder-level entity ('<parent>') to tenant-level entity ('')"*. The error names "tenant-level" because the absence is interpreted as "target is at tenant", which then trips the folder ↔ tenant block. Always pass `referenceFolderKey` for any folder-to-folder `RELATIONSHIP` / `FILE` binding. `CHOICE_SET_*` is not affected — the server resolves from `choiceSetId`.
-
-System entities live at tenant level but are exempt from the folder ↔ tenant block — that's how FILE fields work on folder-scoped entities (they point at the tenant-level `EntityAttachment` system entity). The exemption is specific to system entities; ordinary tenant entities and choice sets stay blocked.
-
-Surface this constraint to the user **before** invoking `entities create` / `addFields` whenever the proposed parent and target sit on opposite sides of the tenant ↔ folder boundary AND the target is not a system entity. Do not silently fall back to a different field type — see Rule 18 (no silent substitution).
-
-**Lookup sequence:**
-
-```bash
-# 1. Find the target's folder and IDs
-uip df entities list --include-folders --output json          # → target entity's Id + FolderId
-uip df entities get <target-entity-id> --folder-key <target-folder-key> --output json   # → target field's Id
-
-# 2. Create the parent in its folder, with the cross-folder reference
-uip df entities create OrderLine \
-  --folder-key <parent-folder-key> \
-  --body '{
-    "fields":[
-      {"fieldName":"order","type":"RELATIONSHIP",
-       "referenceEntityId":"<target-entity-uuid>",
-       "referenceFieldId":"<target-field-uuid>",
-       "referenceFolderKey":"<target-folder-key>",
-       "isRequired": true}
-    ]
-  }' --output json
-```
-
-Same shape applies to `addFields` inside `entities update`. For `CHOICE_SET_*` fields, do **NOT** include `referenceFolderKey` — the server resolves the choice-set's folder from `choiceSetId` alone, even when the choice set lives in a different folder from the parent entity.
+Surface this constraint to the user **before** invoking `entities create` / `addFields` whenever the proposed parent and target sit on opposite sides of the tenant ↔ folder boundary. Do not silently fall back to a different field type — see Rule 18 (no silent substitution).
 
 ### FILE Fields
 
@@ -259,33 +221,8 @@ Same shape applies to `addFields` inside `entities update`. For `CHOICE_SET_*` f
 ```
 
 - **No reference fields required or accepted.** Server auto-wires to the tenant `EntityAttachment` system entity; any caller-supplied `referenceEntityId` / `referenceFieldId` is stripped by the SDK. Never treat these as user-domain choices — no `AskUserQuestion` about which field to bind. The Rule 14 display-field dropdown fires only for `RELATIONSHIP`.
-- **CLI floor:** SDK builds before `@uipath/uipath-typescript` commit `80f9be7a` (branch `fix/df-file-field-refs-optional`, not yet on `main`) throw `Failure / RetryWillNotFix — "Field '<name>' of type FILE requires both referenceEntityId and referenceFieldId"`. On such a build, upgrade the CLI; if that's impossible, pass both UUIDs discovered off any existing FILE field's `Fields[].ReferenceEntity.Id` + `Fields[].ReferenceField.Id`.
 - Write sequence: `entities create` (FILE field, no refs) → `records insert` (no FILE column, Rule 6) → `files upload <entity-id> <record-id> <field-name> --file <path>`. Full surface: [`file-attachments.md`](file-attachments.md).
 
-### Combined Example — mixing scalar, choice-set, and relationship fields
-
-Complex types accept the same standard field options as scalars — `isRequired`, `isUnique`, `displayName`, `description`, `defaultValue`, `isRbacEnabled`, `isEncrypted`, plus type-specific constraints (`lengthLimit`, `maxValue`/`minValue`, `decimalPrecision`). Extras unique to complex types: `choiceSetId` for `CHOICE_SET_*`, `referenceEntityId` + `referenceFieldId` for `RELATIONSHIP`. `FILE` needs no extras (see [FILE Fields](#file-fields)).
-
-```bash
-# Prereqs: target entity exists; choice set exists (look up ID)
-uip df entities create "Expense" --body '{
-  "displayName": "Expense",
-  "description": "Reimbursable expenses with category, tags, and submitter",
-  "fields": [
-    {"fieldName":"invoiceNumber", "type":"STRING",  "isRequired": true, "isUnique": true, "lengthLimit": 50,
-     "displayName":"Invoice Number"},
-    {"fieldName":"amount",        "type":"DECIMAL", "isRequired": true, "decimalPrecision": 2, "minValue": 0,
-     "displayName":"Amount (USD)"},
-    {"fieldName":"notes",         "type":"MULTILINE_TEXT", "lengthLimit": 2000},
-    {"fieldName":"category",      "type":"CHOICE_SET_SINGLE",   "choiceSetId":"<choice-set-id>",
-     "isRequired": true, "displayName":"Category"},
-    {"fieldName":"tags",          "type":"CHOICE_SET_MULTIPLE", "choiceSetId":"<choice-set-id>"},
-    {"fieldName":"customerId",    "type":"RELATIONSHIP", "referenceEntityId":"<customer-entity-uuid>", "referenceFieldId":"<customer-id-field-uuid>",
-     "isRequired": true, "displayName":"Customer"}
-  ]
-}' --output json
-```
-
 ## Deleting an Entity
 
 ```bash
@@ -313,8 +250,8 @@ Irreversible — drops the column and every record's value in it. Note the body
 
 Before invoking, surface the impact to the user **and** run the cascade-ask (data-fabric.md Rule 11):
 
-- **CHOICE_SET_* fields** — choice set is shared. Resolve `Fields[].ChoiceSetId` from `entities get <id>`, list other entities binding that choice set (`entities list --output json` → entries whose `Fields[].ChoiceSetId == <id>`), then raise an `AskUserQuestion` dropdown: `Delete only the field` · `Also delete choice set <Name> (<id>)` · `Stop`. On `Also delete …`, run the choice-set-delete flow ([`choice-sets.md` → Delete a choice set](choice-sets.md#delete-a-choice-set)) with its own dependent-discovery.
-- **RELATIONSHIP fields** — confirm no flow / coded app reads the value. Resolve `Fields[].ReferenceEntity.Id`, list other inbound references (`entities list --output json` → entries whose `Fields[].ReferenceEntity.Id == <id>`), then raise an `AskUserQuestion` dropdown: `Delete only the field` · `Also delete target entity <Name> (<id>)` · `Stop`. On `Also delete …`, run the entity-delete flow (Rule 10) with its own dependent-discovery. The FK column on the parent disappears either way.
+- **CHOICE_SET_* fields** — choice set is shared. Resolve `Fields[].ChoiceSetId` from `entities get <id>`, list other entities binding that choice set (`entities list --output json` → entries whose `Fields[].ChoiceSetId == <id>`), then raise an `AskUserQuestion` dropdown: `Delete only the field` · `Also delete choice set <Name> (<id>)` · `Stop`. On `Also delete …`, run the choice-set-delete flow ([`choice-sets.md` → Deleting a choice set](choice-sets.md#deleting-a-choice-set)) with its own dependent-discovery.
+- **RELATIONSHIP fields** — warn that consumers may depend on the field. Resolve `Fields[].ReferenceEntity.Id`, list other inbound references (`entities list --output json` → entries whose `Fields[].ReferenceEntity.Id == <id>`), then raise an `AskUserQuestion` dropdown: `Delete only the field` · `Also delete target entity <Name> (<id>)` · `Stop`. On `Also delete …`, run the entity-delete flow (Rule 10) with its own dependent-discovery.
 - **FILE fields** — drop only the column. The `referenceEntityId` points at platform-managed FILE storage; do **not** offer to delete it.
 - **System fields** (`Id`, `CreatedBy`, …) can't be removed regardless.
 
@@ -326,9 +263,9 @@ Response: `{ Code: "EntityUpdated", Data: { Id, RemovedFields: ["<name>"], Reaso
 |-----------|--------|
 | Change a field's data type | Not supported — type is fixed at creation and cannot be changed via `updateFields` |
 | Toggle `isUnique` on an existing field (either direction) | Not supported — `isUnique` is fixed at creation. `updateFields` with `isUnique: true/false` returns `Result: Success` but the server silently ignores the change; the Data Fabric UI renders the toggle as **disabled** on existing fields. To enforce uniqueness on a field that doesn't have it: (1) confirm with the user that the field can be recreated, then (2) `removeFields` it (drops all existing values in that column — see Rule 11), then (3) `addFields` with `isUnique: true`. Do NOT report success on a no-op `updateFields` — verify via `entities get` (see Verify-after-update below). |
-| Field name matching a SQL / language keyword | API returns `RESERVED_LANGUAGE_KEYWORDS` — rename before retrying (see Name Validation above) |
+| Field name rejected as a reserved keyword | C#/VB keywords return `RESERVED_LANGUAGE_KEYWORDS`; the CLI also rejects some SQL words such as `Order`, while names such as `Status` and `Key` are accepted. Surface the actual error and ask for a domain-specific rename. |
 
-Record-level writes against FILE fields (insert / update / import) are anti-patterns documented in data-fabric.md Rule 6 and [`records-query.md` → FILE fields](records-query.md#file-fields--never-write-through-insertupdate). This file covers schema only.
+Record-level writes against FILE fields (insert / update / import) are anti-patterns documented in data-fabric.md Rule 6 and [`records-query.md` → FILE fields](records-query.md#file-fields). This file covers schema only.
 
 ---
 
@@ -391,7 +328,7 @@ uip df entities update <entity-id> \
 
 ## System Fields
 
-Every entity has auto-created system fields: `Id`, `CreatedBy`, `CreateTime`, `UpdatedBy`, `UpdateTime`. These are read-only and must not be included in field definitions or CSV imports.
+Every entity has auto-created system fields: `Id`, `CreatedBy`, `CreateTime`, `UpdatedBy`, `UpdateTime`, `RecordOwner`. These are read-only and must not be included in field definitions or CSV imports.
 
 ## Listing and Inspecting Entities
 
@@ -424,7 +361,8 @@ uip df entities get <entity-id> --output json
 
 | Field | Description |
 |------------------------|-------------|
-| `Fields[].Name` | Exact field name for use in record bodies and CSV headers |
+| `Fields[].Name` | Exact, case-sensitive field name for JSON record bodies |
+| `Fields[].DisplayName` | Exact header required by CSV import |
 | `Fields[].FieldDataType.Name` | Data type. Legacy fields may return UI-broken types (`INTEGER` / `FLOAT` / `UUID` / `DATETIME` / …) — see [Supported Field Types](#supported-field-types). |
 | `Fields[].FieldDataType.{LengthLimit,MaxValue,MinValue,DecimalPrecision}` | Type-specific constraint values |
 | `Fields[].Id` | Field UUID — required for `updateFields` in `entities update` |
@@ -436,20 +374,6 @@ uip df entities get <entity-id> --output json
 
 Before writing records, identify complex fields by `FieldDataType.Name` and resolve lookups: `CHOICE_SET_*` → `choice-sets list-values <choice-set-id>` for `NumberId`s; `RELATIONSHIP` → `records query` on `ReferenceEntity.Id` for target record UUIDs.
 
-**Example — discover an entity before writing records:**
-```bash
-# 1. Find the entity ID and confirm it is Native (EntityType == "Entity")
-uip df entities list --native-only --output json
-# e.g. response row: { "Name": "Customer", "Id": "abc-123", "EntityType": "Entity", "DisplayName": "Customer" }
-
-# 2. Get field names for use in record bodies
-uip df entities get abc-123 --output json
-# e.g. Fields: [{"Name": "FullName", "FieldDataType": {"Name": "STRING"}}, {"Name": "Score", "FieldDataType": {"Name": "DECIMAL"}}]
-
-# 3. Insert using exact field names
-uip df records insert abc-123 --body '{"FullName":"Alice","Score":95}' --output json
-```
-
 ## Native vs Federated Entities
 
 Each `entities list` row carries an `EntityType` field (no `Source` field exists):

package/skills/uipath-platform/references/data-fabric/file-attachments.md

@@ -6,13 +6,13 @@ Data Fabric supports file-type fields on entities. Files are stored per-record p
 
 ## Creating a FILE field correctly
 
-The FILE field must be created via the CLI before the UI can upload to it. Body is just `{"fieldName":"X","type":"FILE"}` — server auto-wires the `EntityAttachment` binding. Full shape + CLI-floor caveat in [`entity-schema.md` → FILE Fields](entity-schema.md#file-fields).
+When creating a FILE field through the CLI, use only `{"fieldName":"X","type":"FILE"}`. The server auto-wires the `EntityAttachment` binding. See [`entity-schema.md` → FILE Fields](entity-schema.md#file-fields).
 
 ## Prerequisites
 
 1. **The entity must have a FILE field.** Use `uip df entities get <entity-id> --output json` to identify file-type fields. A correctly-defined FILE field shows `FieldDataType.Name: "FILE"`, `FieldDisplayType: "File"`, `IsForeignKey: true`, and `ReferenceEntity.Name == "EntityAttachment"`.
 2. **The target record must already exist.** `files upload` writes against a `<record-id>` — create the row first with `records insert` (omit the FILE column — Rule 6) and capture `Data.Id` from the response.
-3. **All three `files` commands accept `--folder-key <GUID>`** for records on folder-scoped entities (CLI ≥ `1.197.0`). Required when the parent entity lives in a folder; omit for tenant-scoped entities.
+3. **All three `files` commands accept `--folder-key <GUID>`**. Pass it when the parent entity lives in a folder; omit it for tenant-scoped entities.
 
 ## Upload or Replace a File
 
@@ -94,29 +94,6 @@ Parse by inspecting the field's runtime type (string vs object) — or pin the s
 - Do not try to set, swap, or clear the field via `records insert` / `records update`. Expected behavior: silently dropped (see warning above).
 - To check whether a file is attached, look for the field's presence and non-null value. To clear, call `files delete`.
 
-To read the filename through the CLI: query with `expansionLevel: 1` and read `Data.Items[].<field-name>.Name`. `files upload` also returns it as `Data.FileName` on the upload response.
-
-## Full Workflow
-
-```bash
-# 1. Discover entity and find a record
-uip df entities list --output json
-uip df entities get <entity-id> --output json      # see field names
-
-uip df records list <entity-id> --output json      # record IDs; FILE field shown as UUID string
-
-# 2. Upload
-uip df files upload <entity-id> <record-id> attachment \
-  --file report.pdf --output json
-#    → Data.FileName echoes the uploaded filename
-
-# 3. Read filename and metadata (Name, Size, Type, ...) for that record
-uip df records query <entity-id> \
-  --body '{"expansionLevel":1,"filterGroup":{"logicalOperator":0,"queryFilters":[{"fieldName":"Id","operator":"=","value":"<record-id>"}]}}' \
-  --output json
-#    → Data.Items[0].attachment.Name / .Size / .Type / .UpdateTime
-
-# 4. Verify by downloading
-uip df files download <entity-id> <record-id> attachment \
-  --destination /tmp/report-verify.pdf --output json
-```
+To read the filename through the CLI, query with `expansionLevel: 1` and read
+`Data.Items[].<field-name>.Name`. `files upload` also returns it as
+`Data.FileName`; verify bytes with `files download` when content matters.

package/skills/uipath-platform/references/data-fabric/filter-platform-contract.md

@@ -30,10 +30,10 @@ Example:
 }
 ```
 
-- `value` is always a JSON **string** (`"18"`, `"true"`, ISO-8601 dates) — the server parses it.
+- `value` is a JSON **string** (`"18"`, `"true"`, ISO-8601 dates), except `null` for empty checks.
 - `in` / `not in` use `valueList`; everything else uses `value`.
 - `null` value = is-empty (`=`) / is-not-empty (`!=`).
-- Response: `{ Items, TotalCount, HasNextPage, NextCursor: { Value }, CurrentPage, TotalPages, SupportsPageJump }`. Records live in `Data.Items` (NOT `Data.Records`). Page with `--limit` / `--cursor` flags (pass `NextCursor.Value`), never body keys.
+- Response data: `Data: { Items, TotalCount, HasNextPage, NextCursor: { Value }, CurrentPage, TotalPages, SupportsPageJump }`. Records live in `Data.Items`. Page with `--limit` / `--cursor` flags (pass `NextCursor.Value`), never body keys.
 
 ## Operator support by field type
 

package/skills/uipath-platform/references/data-fabric/records-query.md

@@ -6,8 +6,8 @@
 # First page
 uip df records list <entity-id> --limit 50 --output json
 
-# Next page — pass NextCursor value from previous response
-uip df records list <entity-id> --limit 50 --cursor <NextCursor> --output json
+# Next page — pass Data.NextCursor.Value from the previous response
+uip df records list <entity-id> --limit 50 --cursor <cursor-value> --output json
 ```
 
 Response wrapper: `{ Result, Code: "RecordList" | "RecordQuery", Data: { Items, TotalCount, HasNextPage, NextCursor, CurrentPage, TotalPages, SupportsPageJump } }`.
@@ -39,7 +39,7 @@ Offset-based under the hood. Available on both `records list` and `records query
 
 ## Folder scope (`--folder-key`)
 
-`records list`, `records get`, `records insert`, `records update`, `records delete`, `records query`, and `records import` all accept `--folder-key <GUID>` (CLI ≥ `1.197.0`). Required when the parent entity is folder-scoped; recommended on every destructive op. Look up the parent's folder key from `entities list --include-folders --output json` (`FolderId` per row).
+`records list`, `records get`, `records insert`, `records update`, `records delete`, `records query`, and `records import` all accept `--folder-key <GUID>`. Pass it when the parent entity is folder-scoped. Look up the key from `entities list --include-folders --output json` (`FolderId` per row).
 
 ```bash
 uip df records list  <entity-id> --folder-key <folder-guid> --output json
@@ -48,16 +48,7 @@ uip df records query <entity-id> --folder-key <folder-guid> \
   --output json
 ```
 
-`--folder-key` is forwarded as `X-UIPATH-FolderKey` and threaded through to the SDK — for tenant-scoped entities it's harmless (server resolves by UUID), so passing it defensively never breaks reads.
-
-```bash
-# Sequential sweep
-uip df records list <entity-id> --limit 100 --output json
-uip df records list <entity-id> --limit 100 --cursor "<NextCursor>" --output json
-
-# Jump directly to the page containing record #250 (with --limit 100 → page 3)
-uip df records list <entity-id> --limit 100 --offset 250 --output json
-```
+Omit `--folder-key` for tenant-scoped entities.
 
 ## Always Query the Server for Answers
 
@@ -75,12 +66,12 @@ Pagination uses the same `--limit` / `--cursor` / `--offset` flags as `records l
 
 The `filterGroup` shape, operators, response, and per-type support are in [`filter-platform-contract.md`](filter-platform-contract.md). Beyond the filter, the query body accepts:
 
-- `"selectedFields": ["F1","F2"]` — projection. Default is all fields (data-fabric.md Rule 16).
+- `"selectedFields": ["F1","F2"]` — projection. Default is all fields (data-fabric.md Rule 17).
 - `"sortOptions": [{ "fieldName": "Score", "isDescending": true }]` — server-side sort.
 
 ### Verifying a filter applied
 
-Compare the response's `TotalCount` against an unfiltered baseline. If they match, the filter didn't narrow the result set — re-check the body against the contract.
+Check that every returned record satisfies the requested predicate. Equal filtered and unfiltered counts are valid when every record matches.
 
 ### Nested Filter Groups
 
@@ -203,9 +194,7 @@ Values are the **uppercase strings** above — `"COUNT"` not `"Count"`.
 - When `selectedFields` is present alongside `aggregates`, every entry in `selectedFields` must also appear in `groupBy` — otherwise the API rejects the request. The shortcut: use the same array for both, as in the examples above.
 - `groupBy` and `selectedFields` may reference root-entity fields only — expansions are not supported in aggregate mode.
 - The same `filterGroup`, `sortOptions`, and pagination flags (`--limit`, `--cursor`) work alongside aggregates. Filters are applied **before** grouping (SQL `WHERE`).
-- Choice-set fields in `groupBy` / filters require the numeric `numberId`, not the display label. Discover via the choice-set lookup if you need to filter / group by a choice value.
-
-> Needs `@uipath/data-fabric-tool` `1.0.1+`; older versions silently drop `aggregates`/`groupBy` and return a plain record list — `uip tools install @uipath/data-fabric-tool@latest`.
+- `groupBy` names the choice-set field. Group keys and filter values use numeric `NumberId` values rather than display labels.
 
 ## Insert Records
 
@@ -244,21 +233,11 @@ uip df records insert <entity-id> \
 
 Display labels, choice-value UUIDs, and non-UUID relationship values are rejected — resolve first. Reads echo the same shape.
 
-### FILE fields — never write through insert/update
-
-**Anti-pattern.** Never include a FILE-typed key in `records insert` or `records update` payload (data-fabric.md Rule 6). Expected behavior: the platform silently strips FILE values — paths, base64 blobs, filenames, UUIDs, and `null` — and returns `Result: Success` with the FILE column unchanged. Do not interpret Success as "the file changed." `records update receipt:null` does **not** clear. `records update receipt:"<uuid>"` does **not** swap. To attach, replace, or clear a file, use the `files` verbs documented in [`file-attachments.md`](file-attachments.md). Required write path:
-
-```bash
-# 1. Insert the row WITHOUT the FILE column
-uip df records insert <entity-id> --body '{"title":"Q1 report"}' --output json
-#    → Data.Id is the new record's UUID
-
-# 2. Attach the file to the FILE field on that record
-uip df files upload <entity-id> <record-id> <file-field-name> \
-  --file /local/path/report.pdf --output json
-```
+### FILE fields
 
-`files upload` is both attach and replace — call it directly against the record/field whether the field is currently empty or already has a file (no need to `files delete` first). `files delete` clears the field, `files download` retrieves the binary. CSV `records import` drops `FILE` columns too — see Rule 20. Full file-attachment surface in [`file-attachments.md`](file-attachments.md).
+Never include a FILE key in record insert/update/import payloads; the platform
+silently drops it. Insert the row without that key, then use `files upload`.
+See data-fabric.md Rule 6 and [`file-attachments.md`](file-attachments.md).
 
 ## Update Records
 

package/skills/uipath-platform/references/integration-service/reference-resolution.md

@@ -33,7 +33,7 @@ A reused reference ID:
 
 ## Reference Fields (CRITICAL)
 
-Some fields in the describe `requestFields` have a `reference` section — their value must be looked up from another resource before executing.
+Entries in the describe `requestFields` AND `parameters` (query/path parameters) can have a `reference` section — their value must be looked up from another resource before executing. Scan both arrays: on some connectors the activity's primary input is a path parameter with a reference, and scanning only `requestFields` misses it.
 
 ### Reference structure
 
@@ -61,10 +61,12 @@ Some fields in the describe `requestFields` have a `reference` section — their
 | **`reference.filterPattern`** | Search endpoint pattern — substitute the user's input into `{filter}` and pass as `--query`. See [Search References](#search-references-filterpattern). |
 | **`reference.childPath`** | Scoped child path — used for drill-down references (e.g., folder subfolders) |
 
+> **`objectName` fallback.** If `run list <reference.objectName>` returns 404, the connector uses a symbolic objectName the runner can't resolve (e.g. Data Service `system` → "Entity system does not exist"). Retry with the resource segment of `reference.path`: `/standard-objects` → `run list "<connector-key>" "standard-objects"`.
+
 ### Resolution workflow
 
 ```bash
-# 1. Describe → find fields with "reference" in requestFields
+# 1. Describe → find entries with "reference" in requestFields AND parameters
 uip is resources describe "<connector-key>" "<resource>" \
   --connection-id "<id>" --operation Create --output json
 
@@ -97,6 +99,8 @@ User says: "Send a message to #general"
 
 **Present options to the user** when multiple matches exist. Always use the resolved `lookupValue` (not display names) in `--body` or `--query`.
 
+**Zero matches:** if the completed lookup (`Data.Pagination.HasMore` is `"false"`) finds no entry matching the user's value, do not execute with it — ask the user, presenting the closest candidates as options. Proceed with the unverified value only if the user confirms it.
+
 ---
 
 ## Scope Filtering (CRITICAL)

package/skills/uipath-platform/references/licensing/consumables-report.md

@@ -4,6 +4,24 @@ Report consumption of consumable license units (`AIU`, `AGU`, `RU`, `PLTU`, `HEA
 
 > For full option details, run `uip platform licenses consumables get --help`.
 
+## Command Shape
+
+ONE verb produces all three reports:
+
+```bash
+uip platform licenses consumables get [--mode <summary|daily|folders>] [flags] --output json
+```
+
+1. `get` is mandatory. `uip platform licenses consumables` alone prints group help — no report.
+2. `summary` / `daily` / `folders` are `--mode` VALUES, never subcommands or positionals.
+3. Summary report: omit `--mode` (summary is the default) or pass `--mode summary`.
+
+| Wrong | Right |
+|-------|-------|
+| `uip platform licenses consumables --output json` (missing `get`) | `uip platform licenses consumables get --output json` |
+| `uip platform licenses summary` (verb does not exist) | `uip platform licenses consumables get --output json` |
+| `uip platform licenses consumables get summary` (mode as positional) | `uip platform licenses consumables get --mode summary --output json` |
+
 ---
 
 ## When to Use

package/skills/uipath-platform/references/licensing/licensing.md

@@ -30,7 +30,7 @@ All `uip platform` licensing commands share a set of cross-cutting options:
 |----------|------|--------|
 | Tenant Allocations | [tenant-allocations.md](tenant-allocations.md) | `tenants licenses get/set` — allocate license units to tenant pools |
 | User & Group Licenses | [user-licenses-allocations.md](user-licenses-allocations.md) | `users licenses get/set/available`, `groups rules get/details/set` — assign bundles directly or via group rules |
-| Consumables Report | [consumables-report.md](consumables-report.md) | `licenses consumables get --mode {summary,daily,folders}` — consumption reporting |
+| Consumables Report | [consumables-report.md](consumables-report.md) | `licenses consumables get --mode {summary,daily,folders}` — consumption reporting. `get` is mandatory; summary/daily/folders are `--mode` values, not subcommands (there is no `licenses summary` verb) |
 
 ---
 

package/skills/uipath-platform/references/orchestrator/run-jobs.md

@@ -92,7 +92,7 @@ Key options:
 | `--specific-priority <1-100>` | Numeric priority override (mutually exclusive with `--job-priority`). Use when you need fine-grained ordering inside the same priority bucket. |
 | `--robot-size <Small\|Standard\|Medium\|Large>` | Cloud robot sizing for serverless runtimes |
 | `--input-arguments <json>` | Default input arguments (merged with per-job inputs) |
-| `--environment-variables <json>` | Default environment variables (merged with per-job env) |
+| `--environment-variables <pairs>` | Default environment variables — newline-separated `KEY=VALUE` pairs, **not** JSON (merged with per-job env) |
 | `--tags <list>` | Comma-separated tags for filtering |
 | `--hidden-for-attended` / `--visible-for-attended` | Toggle visibility to attended robot users |
 | `--auto-create-triggers` / `--no-auto-create-triggers` | Auto-create connected triggers on deploy |
@@ -115,6 +115,13 @@ uip or processes resources <process-key-guid> --output json
 # plus --healing-agent / --no-healing-agent (Autopilot for Robots toggle).
 uip or processes update <process-key-guid> --description "Updated description" --output json
 
+# Environment variables are newline-separated KEY=VALUE pairs, not JSON.
+uip or processes update <process-key-guid> --environment-variables $'API_HOST=api.example.com\nRETRIES=3' --output json
+
+# Pass '' to clear them (Orchestrator reads an empty body as "leave them alone",
+# so the CLI sends a bare newline to make the clear actually happen).
+uip or processes update <process-key-guid> --environment-variables '' --output json
+
 # Walk the package version history (every package version this release ever pointed at)
 uip or processes version-history <process-key-guid> --output json
 
@@ -154,7 +161,7 @@ Key options:
 - `--user-keys <guids>` / `--machine-keys <guids>` — comma-separated GUIDs to pin the job to specific identities. With `--strategy ModernJobsCount` they restrict the candidate pool; with `Specific` they're required.
 - `--healing-agent` — enable Autopilot for Robots (Healing Agent) just for this job, regardless of the process-level `--healing-agent` setting on `processes update`. Useful for one-off self-healing without flipping the process default.
 - `--reference <text>` — user-set reference (free-form string) attached to the job. Useful for correlation with external systems.
-- `--environment-variables <json>` — JSON object of per-job environment variables. Merged on top of folder-/process-level env.
+- `--environment-variables <pairs>` — per-job environment variables as newline-separated `KEY=VALUE` pairs (same shape as the process-level flag, **not** JSON). Merged on top of folder-/process-level env. Malformed lines are rejected before the job is submitted.
 - `--run-as-me` — run under the caller's identity instead of resolving an unattended robot account in the folder.
 - `--wait-for-completion` + `--timeout <seconds>` (default 300) + `--poll-interval <seconds>` (default 5) — poll until the job reaches a terminal state.
 - `--output-dir <path>` + `--no-download` — when `--wait-for-completion` is set, the CLI downloads the job's `OutputFile` to this directory automatically. Pass `--no-download` to opt out.

package/skills/uipath-platform/references/orchestrator/setup-environment.md

@@ -146,6 +146,15 @@ uip or roles delete <role-key> --output json
 
 `roles user-permissions` is the right command for "what can this user actually do here" debugging; it accounts for inherited folder roles and tenant overrides. `roles user-roles` is the inverse — given a user, which role assignments exist.
 
+For the forward lookup — "who holds this role" — use `roles users list`:
+
+```bash
+# Principals assigned to a role (users, groups, robots, external apps)
+uip or roles users list <role-key> --output json
+```
+
+`Pagination.Total` is the role's full membership count, so a role with no assignees returns `Data: []` and `Total: 0`. Auditing a whole tenant is therefore one call per role, not a directory sweep per principal.
+
 ### Step 4: Import Users from Identity Service
 
 Principals are managed in Identity Service (IS), not in Orchestrator. `users import` is the **single integration point** between IS and the tenant: it references an existing IS principal and provisions the matching tenant user record. Everything downstream (`users assign`, `users assign-roles`, `roles assign`, etc.) takes the resolved Orchestrator user-key — no further IS round-trips. (The legacy `users create` / `users delete` commands are gone — they called endpoints reserved for `ProvisionType=Manual`, which is not how cloud or IS-backed users are managed.)

package/skills/uipath-platform/references/traces/feedback.md

@@ -86,7 +86,7 @@ uip traces feedback list detailed \
   --output json
 ```
 
-Additional flags over `list`: `--since <duration>`, `--after <ISO>`, `--before <ISO>`, `--category-id <guid>`, `--sortBy`, `--sortDir`. Max 200 items.
+Additional flags over `list`: `--since <duration>`, `--after <ISO>`, `--before <ISO>`, `--category-id <guid>` (repeatable), `--sort-by <createdAt|updatedAt>`, `--sort-order <asc|desc>`. Max 200 items.
 
 ## update
 
@@ -102,9 +102,12 @@ uip traces feedback update <feedback-id> \
 
 ## delete
 
+`-y` is required — the CLI never prompts, so a delete without it is rejected.
+
 ```bash
 uip traces feedback delete <feedback-id> \
   --folder-key <folder-key> \
+  -y \
   --output json
 ```