@uipath/skills 1.195.0

package/skills/uipath-rpa/references/project-structure.md

@@ -0,0 +1,135 @@
+# UiPath Project Structure
+
+## Directory Layout
+
+```
+MyProject/
+├── project.json          # Project manifest (name, dependencies, settings)
+├── Main.xaml             # Default entry point (XAML mode) ─┐ typically one
+├── Main.cs               # Default entry point (coded mode) ─┘ or the other
+├── *.xaml                # Additional XAML workflow files
+├── *.cs                  # Coded workflows, test cases, and source files
+├── *.cs.json             # Auto-generated by Studio — do not create manually
+├── .codedworkflows/      # Auto-generated coded workflow support files (ConnectionsFactory.cs, ConnectionsManager.cs, ISConnections.cs, etc.)
+├── .entities/            # Data Fabric entity manifest — EntitiesStore.json. Committed; source of truth for which entities are bound to the project. Managed via uip rpa data-fabric-entities install.
+├── .local/               # Local cache (package restore, compiled artifacts)
+│   ├── install/          # Restored NuGet packages
+│   ├── docs/             # Auto-generated activity documentation
+│   │   └── packages/     # Per-package doc folders
+│   ├── .codedworkflows/  # Auto-generated (ObjectRepository.cs, CodedWorkflow.cs, WorkflowRunnerService.cs)
+│   └── .entities/        # Compiled Data Fabric entity assemblies (DataService.<Namespace>.dll) per install signature. Regenerated on demand — do not edit.
+├── .objects/             # Object Repository metadata (UI element selectors)
+├── .project/             # Project metadata
+│   ├── JitCustomTypesSchema.json  # JIT-compiled custom type definitions
+│   └── PackageBindingsMetadata.json
+├── .screenshots/         # Activity screenshots (auto-generated)
+├── .settings/            # Project-level settings
+├── .autopilot/           # Autopilot service specific files
+│   └── skills/           # Project-specific Autopilot skills
+└── .storage/             # Activity resource storage (bucket-organized)
+    ├── .design/          # Design-time only resources (NOT packed into published package)
+    │   └── <bucket>/     # Named bucket to prevent conflicts
+    └── .runtime/         # Runtime resources (packed into published NuPkg)
+        └── <bucket>/     # Named bucket with resource files
+```
+
+### Coded-Only Elements
+
+- `.cs` files with `[Workflow]`/`[TestCase]` attributes — executable coded automations
+- `.cs.json` metadata files — auto-generated by Studio for each coded workflow/test case (do not create manually)
+- `.codedworkflows/` — auto-generated support files (only when project has `.cs` files)
+- `.local/.codedworkflows/` — auto-generated `ObjectRepository.cs`, `CodedWorkflow.cs`, etc.
+- `.variations/` — data-driven test parameters (Tests projects only)
+
+### XAML-Only Elements
+
+- `.xaml` workflow files — visual workflow definitions
+- Expression language configured in `project.json` (`VisualBasic` or `CSharp`)
+
+## project.json Key Fields
+
+```json
+{
+  "name": "MyProject",
+  "description": "",
+  "main": "Main.xaml",
+  "dependencies": {
+    "UiPath.System.Activities": "[24.12.1]"
+  },
+  "schemaVersion": "4.0",
+  "studioVersion": "25.0.0.0",
+  "projectVersion": "1.0.0",
+  "runtimeOptions": {
+    "autoDispose": false,
+    "netFramework": { "targetFramework": "net6.0-windows" },
+    "isPausable": true,
+    "isAttended": false,
+    "requiresUserInteraction": false
+  },
+  "designOptions": {
+    "projectProfile": "Developement",
+    "outputType": "Process",
+    "libraryOptions": {
+      "includeOriginalXaml": false,
+      "privateWorkflows": []
+    }
+  },
+  "expressionLanguage": "VisualBasic",
+  "entryPoints": [
+    {
+      "filePath": "Main.xaml",
+      "uniqueId": "2f510550-3882-4340-9239-53a24d0717f6",
+      "input": [],
+      "output": []
+    }
+  ],
+  "targetFramework": "Windows"
+}
+```
+
+### Important Fields
+
+| Field | Description |
+|-------|-------------|
+| `name` | Project name (used in package output) |
+| `main` | Entry point workflow file (relative path) |
+| `dependencies` | NuGet package dependencies with version constraints |
+| `expressionLanguage` | `CSharp` or `VisualBasic` — determines expression syntax in XAML. Default `VisualBasic`. Immutable after creation (decide at init — SKILL.md Rule 2a) |
+| `designOptions.outputType` | `Process`, `Library`, or `Tests` |
+| `targetFramework` | `Windows` (.NET 6 Windows-only), `Portable` (Cross-platform .NET 6+), or `Legacy` (Windows - Legacy, .NET Framework 4.6.1). Set explicitly at init (Rule 2a); omitting `--target-framework` yields `Windows` |
+| `entryPoints` | Per-workflow metadata: filePath, uniqueId, input/output definitions (**Process projects only** — Tests and Library projects use empty `[]`) |
+
+## Rules
+
+1. **Use CLI for dependencies**: Always use `uip rpa packages install` to add/update dependencies. Do not manually edit `dependencies` in `project.json`.
+2. **Do not edit `.local/` or `.objects/`**: These are cache directories managed by the build system.
+3. **`main` entry point**: The default entrypoint that gets run if not specified otherwise. `entryPoints` array is only populated for **Process** projects — Tests and Library projects leave it empty (`[]`).
+4. **`--project-dir` awareness**: All `uip rpa` commands default to the current working directory. If the CWD is not the project root, pass `--project-dir "{projectRoot}"` explicitly.
+5. **Creating new projects**: Use `uip rpa init`. See [environment-setup.md](environment-setup.md).
+
+## Common Activity Packages
+
+| Package ID | Description | Key Activities |
+|------------|-------------|----------------|
+| `UiPath.System.Activities` | Core system activities | Assign, If, ForEach, While, Invoke Workflow, Log Message, Delay |
+| `UiPath.UIAutomation.Activities` | UI interaction | Click, Type Into, Get Text, Open Browser, Use Application/Browser |
+| `UiPath.Excel.Activities` | Excel automation | Read Range, Write Range, Read Cell, Write Cell, Format Range |
+| `UiPath.Mail.Activities` | Email operations | Send Mail, Get Mail, Save Attachments, Forward Mail |
+| `UiPath.Database.Activities` | Database operations | Execute Query, Execute Non Query, Connect, Disconnect |
+| `UiPath.WebAPI.Activities` | HTTP/REST calls | HTTP Request, Deserialize JSON, Serialize JSON |
+| `UiPath.PDF.Activities` | PDF processing | Read PDF Text, Read PDF with OCR, Extract Data From PDF |
+| `UiPath.Word.Activities` | Word automation | Read Text, Replace Text, Insert Image, Export to PDF |
+| `UiPath.Testing.Activities` | Testing and assertions | Verify Expression, Verify Are Equal, Generate Test Data |
+| `UiPath.Presentations.Activities` | PowerPoint automation | Add Slide, Replace Text, Insert Image |
+| `UiPath.IntegrationService.Activities` | Integration Service connector runtime | Generic connector activities for Salesforce, ServiceNow, HubSpot, etc. |
+| `UiPath.Cryptography.Activities` | Encryption/hashing | Encrypt Text, Decrypt Text, Hash File |
+
+## Version Constraints
+
+Dependencies use NuGet version constraint syntax:
+
+| Syntax | Meaning |
+|--------|---------|
+| `[1.0.0]` | Exact version 1.0.0 |
+| `[1.0.0, )` | Version 1.0.0 or higher |
+| `[1.0.0, 2.0.0)` | Between 1.0.0 (inclusive) and 2.0.0 (exclusive) |

package/skills/uipath-rpa/references/publishing-guide.md

@@ -0,0 +1,80 @@
+# Publishing a UiPath Project
+
+How to take a built `.nupkg` from `uip rpa pack` and get it onto Orchestrator or Studio Web. Covers the standalone-project paths only — solution publish (`.uipx` solutions and `solution publish` deploy lifecycle) lives in [/uipath:uipath-solution](../../uipath-solution/SKILL.md).
+
+## Pick a path
+
+| Goal | Path | Reference |
+|---|---|---|
+| Run the project as an Orchestrator process / link as a Test Manager automation | **Pack → Orchestrator package upload** | This file § Pack → Upload |
+| Edit / visualize in Studio Web | **Solution upload** | [uipath-solution](../../uipath-solution/SKILL.md) (solution upload) |
+| Deploy a packed solution (`.uipx`) to Orchestrator with the deployment lifecycle | **Solution publish** | [uipath-solution](../../uipath-solution/references/operate/pack-and-deploy.md) |
+
+This file documents the first row only — the legacy Orchestrator package feed flow that `uip tm testcases link-automation` requires.
+
+## Pack → Upload (Orchestrator process flow)
+
+The end-to-end is two CLI calls.
+
+### Step 1 — Pack the project
+
+```bash
+uip rpa pack "<PROJECT_DIR>" "<OUTPUT_DIR>" --output json
+```
+
+| Argument | Position | Notes |
+|---|---|---|
+| `<PROJECT_DIR>` | Positional 1 | Path to the project (folder containing `project.json`). |
+| `<OUTPUT_DIR>` | Positional 2 | Directory the `.nupkg` is written to. Must exist. |
+
+Common optional flags (run `uip rpa pack --help` for the full set):
+- `--package-version <SEMVER>` — pin the version. Defaults to the project version.
+- `--skip-analyze` — skip the workflow-analyzer pass. Use only for known-clean builds.
+- `--governance-file-path <PATH>` — apply a governance policy during pack.
+
+Output (JSON) emits `OutputPath` — the full `.nupkg` path. Capture it for Step 2.
+
+> **`uip rpa pack` does NOT accept `--project-path` or `--project-dir`.** Both arguments are positional. The `--project-dir` flag exists on most other `uip rpa` subcommands but not here.
+
+### Step 2 — Upload to Orchestrator
+
+```bash
+uip or packages upload "<NUPKG_PATH>" --output json
+```
+
+| Argument / Flag | Required | Notes |
+|---|---|---|
+| `<NUPKG_PATH>` | Yes (positional) | Path to the `.nupkg` produced by `pack`. |
+| `--feed-id <UUID>` | No | Target a non-default feed. Defaults to the tenant feed. |
+| `-t, --tenant <NAME>` | No | Override the authenticated tenant. |
+
+Output JSON includes the package `Id` (the package name Orchestrator stores) and `Version`. Hold on to the `Id` — it is the `--package-name` value that `uip tm testcases link-automation` and `uip or processes create` need.
+
+> **There is no `uip or packages publish` or `uip rpa publish`.** Agents that try those names get "unknown command". Pack writes a file; upload pushes that file. Two commands, two domains (`rpa`, `or`).
+
+## Discovery cheatsheet
+
+Folder key (UUID — required by `processes create`, `link-automation`, etc.):
+
+```bash
+uip or folders list-current-user --output json
+```
+
+The returned `Key` is the UUID; the `FullyQualifiedName` is the human path. Either is accepted by `--folder-path` / `--folder-key` — most other CLI calls require the UUID.
+
+After upload, list the new package version:
+
+```bash
+uip or packages list --output json
+```
+
+## End-to-end: link a coded test case to Test Manager
+
+For the full Pack → Upload → Link → Execute pipeline targeted at Test Manager (folder-key discovery, picking the right `--test-name`, etc.), see [/uipath:uipath-test § publish-and-link-guide.md](../../uipath-test/references/publish-and-link-guide.md).
+
+## Common pitfalls
+
+- **`uip solution publish` expects a packed `.zip`, not a project directory.** Solutions: run `uip solution pack` first, then `uip solution publish "<ZIP_PATH>"`. Single projects: use `uip or packages upload` instead.
+- **Confusing `solution upload` and `solution publish`.** `upload` pushes to Studio Web (browser editing). `publish` pushes a packed solution `.zip` to the Orchestrator solution feed for `solution deploy`. They are NOT interchangeable. See [uipath-solution](../../uipath-solution/SKILL.md) for the decision tree.
+- **Re-uploading the same version.** Orchestrator rejects duplicate `<id>:<version>` uploads. Bump `--package-version` (or `project.json` `projectVersion`) before re-packing.
+- **`pack` succeeds but `analyze` ran with errors.** A successful pack with errors in the analyzer log usually means warnings only. Re-run `uip rpa analyze --project-dir "<PROJECT_DIR>"` if you need a clean failure / pass signal.

package/skills/uipath-rpa/references/reframework-guide.md

@@ -0,0 +1,178 @@
+# REFramework Guide
+
+Patterns for building and customizing Robotic Enterprise Framework projects on Windows, Portable, or Legacy targets. State-machine internals are in [legacy/activity-docs/_REFRAMEWORK.md](legacy/activity-docs/_REFRAMEWORK.md) — that guide's architecture sections are mode-agnostic.
+
+## When to Use REFramework
+
+Use:
+- Multi-item transactional processing (invoices, queue items, data rows).
+- Production-grade retry, logging, and exception handling.
+- Multi-robot horizontal scaling on a shared Orchestrator queue.
+
+Don't use:
+- Simple linear processes (read → do one thing → exit). Plain `Sequence` is enough.
+- Attended automations with continuous user interaction.
+- Single-call jobs under ~30 seconds total. The four-state ceremony costs more than it saves.
+
+## The Four States
+
+| State | Role |
+|-------|------|
+| `Init` | `InitAllSettings.xaml` reads `Config.xlsx` → `Config` dictionary; `KillAllProcesses.xaml`; `InitAllApplications.xaml` opens/authenticates apps. |
+| `Get Transaction Data` | `GetTransactionData.xaml` returns the next item or `Nothing`. `Nothing` → End Process. |
+| `Process Transaction` | `Process.xaml` (your business logic) → `SetTransactionStatus.xaml` (Success / BusinessRuleException / System Exception). |
+| `End Process` | `CloseAllApplications.xaml` runs on every exit (success or abort). |
+
+Full state machine, transitions, and per-state counter semantics: [legacy/activity-docs/_REFRAMEWORK.md § State Machine Architecture](legacy/activity-docs/_REFRAMEWORK.md).
+
+## Execution Mode: Queue-Driven (Canonical)
+
+The default and most common mode. Dispatcher project populates an Orchestrator queue; this Performer project consumes one item per transaction. Multi-robot parallelism comes for free via queue locking.
+
+**Wiring — keep the template as-is.** The shipped REFramework is built for this mode end-to-end.
+
+1. `Config.xlsx` Settings sheet: set `OrchestratorQueueName` (case-sensitive, must match the queue in Orchestrator) and optionally `OrchestratorQueueFolder`.
+2. `Framework\GetTransactionData.xaml`: uses the `Get Transaction Item` activity. Returns a `QueueItem` or `Nothing` (queue empty → End Process).
+3. `Framework\Process.xaml`: implement business logic. Access fields via:
+   ```vb
+   in_TransactionItem.SpecificContent("FieldName").ToString()
+   in_TransactionItem.Reference
+   in_TransactionItem.Priority
+   in_TransactionItem.DueDate
+   ```
+4. `Framework\SetTransactionStatus.xaml`: keep the three Set Transaction Status calls — they update item status in Orchestrator.
+
+**Dispatcher pattern (separate project).** Read input data, then for each row emit `Add Queue Item` with a unique `Reference`, optional `Priority` / `DueDate`, and the fields as `SpecificContent`. Dispatcher does not need REFramework — a simple `Sequence` is sufficient.
+
+**Concurrency.** Orchestrator locks each item to one robot for the duration of processing. Design `Process.xaml` **stateless** so any robot can pick up any item. To scale throughput, add robots — do not add intra-robot parallelism.
+
+## Execution Mode: Tabular Data
+
+Single robot, no Orchestrator queue. Source data is an Excel/CSV/DataTable. The Academy course "REFramework with Tabular Data" (v2024.10) is the reference pattern.
+
+**Wiring — customize these surfaces.**
+
+1. `Config.xlsx` Settings sheet: blank or remove `OrchestratorQueueName`; add `DataSourcePath` and `DataSourceSheet`.
+2. `Framework\InitAllSettings.xaml` (or a custom init step): Read Range → `io_dt_TransactionData`. **Read the source once**, not per transaction — repeated reads cause file locks and waste cycles.
+3. `Framework\GetTransactionData.xaml`:
+   ```vb
+   If in_TransactionNumber > io_dt_TransactionData.Rows.Count Then
+     out_TransactionItem = Nothing                  ' signals "no more data"
+   Else
+     out_TransactionItem = io_dt_TransactionData.Rows(in_TransactionNumber - 1)
+   End If
+   ```
+   Assumes `TransactionNumber` is 1-indexed (Config.xlsx default `TransactionNumber = 1`, incremented by `SetTransactionStatus.xaml`). If your template starts at 0, use `>=` and drop the `- 1`.
+4. `Framework\Process.xaml`: access fields via `in_TransactionItem("ColumnName").ToString()`.
+5. `Framework\SetTransactionStatus.xaml`: **delete the three Set Transaction Status activities.** They target Orchestrator queues and have no purpose here. Replace with a status-column write-back to the source DataTable, an output Excel/CSV, or `Log Message` calls keyed by row index.
+
+**Type migration.** Changing `TransactionItem`'s type from `QueueItem` to `DataRow` cascades across every `TransactionItem` argument in the Framework workflows and every matching `InvokeWorkflowFile` binding in `Main.xaml`. Update them together or `InvokeWorkflowFile` reports argument-mismatch errors at design time. See [Gotchas § type migration](#gotchas) for the file/argument list.
+
+## Execution Mode: Single-Shot
+
+One execution, no transaction loop. Useful for scheduled jobs that just need REFramework's init/cleanup discipline (open apps, do one thing, close apps).
+
+**Wiring.**
+
+1. `Config.xlsx`: blank `OrchestratorQueueName`.
+2. `Framework\GetTransactionData.xaml`: return a sentinel on call 1, `Nothing` on call 2:
+   ```vb
+   If in_TransactionNumber = 1 Then
+     out_TransactionItem = New Object()             ' placeholder, NOT New QueueItem()
+   Else
+     out_TransactionItem = Nothing
+   End If
+   ```
+3. `Framework\Process.xaml`: implement the single unit of work. `in_TransactionItem` is a sentinel — ignore it.
+4. `Framework\SetTransactionStatus.xaml`: **delete the three Set Transaction Status activities** (same reason as tabular). Log-only is fine.
+
+**Type migration.** Type `TransactionItem` as `System.Object` across every Framework workflow and every `InvokeWorkflowFile` binding. See [Gotchas § type migration](#gotchas).
+
+## Exception Handling Strategy
+
+| Exception | Class | Retry? | Counter behavior |
+|-----------|-------|--------|------------------|
+| Business Rule Exception | `UiPath.Core.BusinessRuleException` | No — data won't fix itself | `ConsecutiveSystemExceptions` resets to 0 |
+| System Exception | `System.Exception` (any other) | Yes — retry per transaction up to `MaxRetryNumber`; re-initialize apps between retries | `ConsecutiveSystemExceptions` increments; hitting `MaxConsecutiveSystemExceptions` aborts to End Process |
+
+Throw business exceptions explicitly in `Process.xaml`:
+
+```vb
+Throw New BusinessRuleException("Invoice amount cannot be negative")
+```
+
+Do NOT wrap `Process.xaml` in a catch-all `TryCatch` — the framework's outer handler is what classifies and routes the exception. Catch only exceptions you intend to translate to a `BusinessRuleException`.
+
+Counter semantics — `MaxRetryNumber` (per transaction, resets per item) vs `MaxConsecutiveSystemExceptions` (global, resets on any success or BusinessRuleException): see [legacy/activity-docs/_REFRAMEWORK.md § MaxRetryNumber vs MaxConsecutiveSystemExceptions](legacy/activity-docs/_REFRAMEWORK.md).
+
+## Configuration Management
+
+- Store all configurable values in `Config.xlsx` — three sheets: `Settings` (key-value, edited per environment), `Constants` (rarely change), `Assets` (Orchestrator asset names, fetched at runtime).
+- Sensitive values (credentials, API keys, tokens) → **Orchestrator Assets**, never `Config.xlsx` cell values.
+- Asset names on the Assets sheet must match Orchestrator exactly (case-sensitive).
+- Config values come back as `String` — convert explicitly: `CInt(in_Config("MaxRetryNumber"))`, `CDate(in_Config("Deadline"))`.
+- Guard missing keys: check `in_Config.ContainsKey(<name>)` or set defaults before first read.
+- Never hardcode paths, URLs, credentials, or environment-specific settings in workflows. Always indirect through `in_Config(<name>)`.
+
+## Idempotency and Concurrency (Queue-Driven)
+
+Performer workflows must be safe to retry. The framework re-executes `Process.xaml` after a System Exception with the same `TransactionItem`.
+
+- Avoid double-posting (check-then-act, or use idempotency tokens from the source system).
+- Avoid relying on in-memory state from a prior transaction — design stateless.
+- Orchestrator handles queue-item locking; do not add custom locking logic.
+- Multiple robots on the same queue: each locks one item while processing. To scale throughput, add robots — not intra-robot parallelism.
+- Validate `SpecificContent` fields at the start of `Process.xaml` — don't trust the Dispatcher.
+
+## Gotchas
+
+### Don't return `New QueueItem()` as a sentinel in non-queue modes
+
+`Framework\SetTransactionStatus.xaml` gates its Orchestrator calls on `in_TransactionItem.GetType is GetType(UiPath.Core.QueueItem)`. `New QueueItem()` satisfies this check — so a synthetic empty `QueueItem` returned from a tabular or single-shot `GetTransactionData.xaml` cascades into 6 retries × 3 branches of `OrchestratorHttpException: 404 (Not Found)`.
+
+**Right fix:** delete the Set Transaction Status activities from `SetTransactionStatus.xaml` for non-queue modes (see the per-mode wiring above) and return `Nothing` / non-`QueueItem` sentinels from `GetTransactionData.xaml`.
+
+### `Config.xlsx OrchestratorQueueName="ProcessABCQueue"` template leftover
+
+The shipped template ships with the sample value `OrchestratorQueueName = "ProcessABCQueue"`. Tabular and single-shot users rarely overwrite it. A Config-string check (e.g., `Not String.IsNullOrEmpty(in_Config("OrchestratorQueueName").ToString())`) is therefore insufficient on its own — the leftover sample value passes. **Blank or remove the row** in non-queue projects.
+
+### Type migration cascade
+
+If you migrate `TransactionItem`'s type away from `QueueItem` (tabular → `DataRow` or `Object`; single-shot → `Object`), update every site, not just `Main.xaml`'s variable:
+
+| File | Argument |
+|------|----------|
+| `Main.xaml` | `TransactionItem` variable |
+| `Framework\GetTransactionData.xaml` | `out_TransactionItem` |
+| `Framework\Process.xaml` | `in_TransactionItem` |
+| `Framework\SetTransactionStatus.xaml` | `in_TransactionItem` |
+| `Framework\RetryCurrentTransaction.xaml` | `in_TransactionItem` (if present) |
+| `Main.xaml` `InvokeWorkflowFile` bindings | every `in_/out_/io_TransactionItem` binding |
+
+Updating one file but not the others surfaces as `InvokeWorkflowFile` argument-mismatch errors at design time.
+
+### Advanced: one `SetTransactionStatus.xaml` for all modes
+
+If you want a single `SetTransactionStatus.xaml` that handles all three modes (rare — usually it's cleaner to delete the Orchestrator calls in non-queue modes), type `in_TransactionItem` as `System.Object` and replace the three FlowDecision conditions with a type-safe guard:
+
+```vb
+TypeOf in_TransactionItem Is UiPath.Core.QueueItem AndAlso DirectCast(in_TransactionItem, UiPath.Core.QueueItem).QueueDefinitionId > 0
+```
+
+`TypeOf ... Is` short-circuits on non-`QueueItem` references; `QueueDefinitionId > 0` filters out empty `New QueueItem()` instances. Requires the full `Object`-typed migration above.
+
+## Customization Checklist
+
+Before first run:
+
+- [ ] **Pick execution mode** — queue-driven / tabular / single-shot.
+- [ ] **Set or blank `OrchestratorQueueName`** in `Config.xlsx` per mode. Sample value `ProcessABCQueue` must not survive into non-queue projects.
+- [ ] **Configure `GetTransactionData.xaml`** for the chosen mode. Never return `New QueueItem()` as a sentinel in non-queue modes — return `Nothing` (terminating) or a non-`QueueItem` value.
+- [ ] **For tabular / single-shot:** delete the three Set Transaction Status activities from `SetTransactionStatus.xaml`. Replace with status-column write-back or log-only.
+- [ ] **For tabular / single-shot:** migrate every `TransactionItem` argument type (see [Gotchas § type migration](#type-migration-cascade)).
+- [ ] **`InitAllApplications.xaml`** — implement app-open/login for every application the process touches.
+- [ ] **`CloseAllApplications.xaml`** + **`KillAllProcesses.xaml`** — graceful close + force-kill fallback for every app process name.
+- [ ] **Classify exceptions in `Process.xaml`** — throw `BusinessRuleException` for data issues; let everything else propagate.
+- [ ] **Move secrets to Orchestrator Assets** — credentials, API keys, environment-specific URLs.
+- [ ] **Set `MaxRetryNumber = 0` during development** to surface failures fast; restore the production value before deployment.
+- [ ] **Verify**: run a synthetic transaction through every exit branch (Success, BusinessRuleException, System Exception → retry, System Exception → abort).

package/skills/uipath-rpa/references/tenant-library-search-guide.md

@@ -0,0 +1,111 @@
+# Tenant Library Search
+
+Discover libraries already deployed to the tenant feed. Use whenever the user wants to "leverage", "reuse", "find", or "use existing" libraries — typically before adding NuGet dependencies to a new RPA project, or when planning which utilities a project should consume.
+
+## Default search target: tenant feed, not local filesystem
+
+The tenant feed is authoritative for org-published libraries. Do NOT search the local filesystem, project folder, NuGet.org, or `git grep` for "shared library" candidates — those surfaces do not represent what the org has deployed.
+
+## CLI surface
+
+One command, one global filter:
+
+```bash
+uip resource libraries list --limit 500 --output json
+```
+
+Returns `Data: [{ Key, Title, Version, Authors }]`. `Key` is `PackageId:Version` and is always populated. `Title` can be `null`.
+
+| Flag | Purpose |
+|------|---------|
+| `--limit <N>` | Items per call (default 50). Use 500 to cover most tenants in one call. |
+| `--offset <N>` | Pagination offset. Use only if `Data.length == --limit`. |
+| `--sort-by "<field> <asc\|desc>"` | Sort. Default `Id desc`. |
+| `--output-filter "<JMESPath>"` | Global filter, evaluated client-side after the API returns. |
+| `-t, --tenant <name>` | Override default tenant. |
+
+There is **no `--search` flag** and **no `--feed-id` flag** on `libraries list`. Filter via `--output-filter`.
+
+## JMESPath filter recipe
+
+`Title` can be `null`, so `contains(Title, 'X')` errors out unless guarded. Always use:
+
+```bash
+# Single keyword
+uip resource libraries list --limit 500 \
+  --output-filter "[?Title != null && contains(Title, 'Excel')]" \
+  --output json
+
+# Multi-keyword OR
+uip resource libraries list --limit 500 \
+  --output-filter "[?Title != null && (contains(Title, 'Common') || contains(Title, 'Shared'))]" \
+  --output json
+```
+
+For case-insensitive matching, lowercase the keyword in the filter and the field: `contains(to_string(Title), 'common') || contains(to_string(Title), 'Common')` — or run unfiltered and rank in-agent.
+
+### Authors-field filter
+
+For orgs that publish libraries with cryptic Titles but a stable `Authors` value, filter on `Authors` instead of `Title`:
+
+```bash
+uip resource libraries list --limit 500 \
+  --output-filter "[?Authors != null && contains(Authors, '<OrgName>')]" \
+  --output json
+```
+
+Combine `Title` and `Authors` filters with `||` when the org uses both conventions inconsistently.
+
+## Procedure
+
+1. **Auth preflight.** Run a benign call once: `uip resource libraries list --limit 1 --output json`. If `Result == "Failure"` with an auth-related message, surface it and switch to the manual fallback (below). Do NOT retry silently.
+2. **Extract keywords** from the source (user prompt, plan tasks, surrounding workflow names). Cap at 6:
+   - Org-prefix terms: `Common`, `Shared`, `Utils`, `Helpers`, `<Company>` if known
+   - Capability terms: `Excel`, `SAP`, `ServiceNow`, `Salesforce`, `Email`, `PDF`, `SharePoint`, `Outlook`, `Citrix`, etc. — drawn from the activities the project will use
+   - Domain terms: `Invoice`, `Vendor`, `Banking`, `Order` — drawn from the project name and request
+
+   If you have more than 6 candidate keywords, **skip the OR-filter** and run unfiltered (`--limit 500`, paginate via `--offset` until `Data.length < limit`); rank in-agent. Splitting a long keyword set across multiple OR-filtered calls is an anti-pattern (#7 below).
+3. **Run one filtered call covering all keywords** with the OR pattern above. Single call, not one per keyword. Branch on the result: ≥1 candidate after ranking → step 5a. 0 candidates → step 5b. Do not loop back to step 2 with new keyword permutations.
+4. **Rank candidates in-agent.**
+   - Org-prefix match in `Title` or `Key` (starts with `Common`, `Shared`, `<Company>`) → rank highest
+   - Capability/domain match in `Title` → rank next
+   - Authors equal to the user's org → boost
+   - De-duplicate by `Title` keeping the latest `Version`
+5a. **If ≥1 candidate — present top 5 via `AskUserQuestion` with `multiSelect: true`.** Each option label: `<PackageId> <Version> — <Title>`. Always include "None / skip" as a non-multiSelect-exclusive option (or describe it as "leave all unchecked").
+5b. **If 0 candidates — present a single-select numbered fallback.** Do not run more filtered calls with new keywords:
+
+   > No org-published libraries matched the search. How would you like to proceed?
+   >
+   > 1. **Proceed without shared libraries** *(recommended)* — install only public NuGet dependencies
+   > 2. **Search a specific name or prefix** — re-run with the team's actual library naming convention
+   > 3. **Provide names manually** — name libraries to install even if not yet deployed; flag as `[VERIFY DEPLOYMENT]`
+   > 4. **Pause and re-authenticate to a different tenant** — if libraries live elsewhere
+
+6. **Record the user's selection.** For each accepted library, run `uip rpa packages install --packages '[{"id": "<PackageId>", "version": "<Version>"}]' --output json` to add it to `project.json`. Verify after install with `uip rpa validate --output json`.
+
+## Skip when
+
+- An SDD already records "Shared libraries referenced" in §16 — those have been confirmed and the package list flows from the SDD. Do not re-prompt.
+- The user has explicitly said "no shared libraries" earlier in the session.
+- The task is pure UI capture / authoring with no new dependencies.
+
+## Manual fallback (auth preflight failed)
+
+If `uip` is unauthenticated, ask the legacy question:
+
+> Tenant library search is unavailable (not authenticated to a UiPath tenant). Provide shared libraries manually?
+>
+> 1. **Skip — no shared libraries** *(recommended)*
+> 2. **Yes — `CommonLibrary`** (the conventional default)
+> 3. **Yes — other** (you name them)
+> 4. **Authenticate first** — run `uip login`, then re-invoke the skill
+
+## Anti-patterns
+
+1. **Searching the local filesystem first.** Tenant is authoritative; local matches do not indicate org adoption.
+2. **Using `--search`.** That flag does not exist on `uip resource libraries list`. Filter via `--output-filter`.
+3. **Using `--feed-id`.** That flag does not exist on `uip resource libraries list` (it does on `uip or packages list` — different command). The libraries command always targets the default tenant feed.
+4. **Calling `contains(Title, ...)` without `Title != null` guard.** Tenants commonly hold packages with null Title — the call fails fast with `Invalid type: contains() expected ... received type null`.
+5. **Listing all libraries with no `--limit` bump, or paginating past the end.** Default 50 truncates large tenants and silently misses candidates. Use `--limit 500` for a one-shot scan; paginate via `--offset` only if `Data.length == 500`. If `Data.length < --limit` on a paginated call, you have seen the entire feed — stop searching, do not run more filtered queries hoping for hidden matches.
+6. **Auto-installing a candidate.** Library installation modifies `project.json` and project compilability — always confirm via `AskUserQuestion` before invoking `packages install`.
+7. **One CLI call per keyword, or running more keyword permutations after a zero-result filtered call.** Combine keywords into one OR-filtered call. On zero results, escalate to step 5b — do not loop back with new keyword sets hoping for hidden matches.