@uipath/skills 1.195.0

package/skills/uipath-rpa/references/legacy/error-handling-guide.md

@@ -0,0 +1,255 @@
+# Error Handling Guide
+
+Structured error handling patterns for legacy UiPath RPA workflows. Use this guide when designing exception handling strategy for any workflow.
+
+For TryCatch XAML syntax, see [activity-docs/_BUILT-IN-ACTIVITIES.md](./activity-docs/_BUILT-IN-ACTIVITIES.md).
+For REFramework exception flow, see [activity-docs/_REFRAMEWORK.md](./activity-docs/_REFRAMEWORK.md).
+For Throw expression escaping, see [common-pitfalls.md](./common-pitfalls.md).
+
+---
+
+## 1. Exception Classification
+
+Every exception in UiPath falls into one of two categories. Classify correctly — the wrong choice causes either wasted retries or skipped valid data.
+
+| | Business Rule Exception | System Exception |
+|---|---|---|
+| **Class** | `UiPath.Core.BusinessRuleException` | `System.Exception` (or any subclass) |
+| **Cause** | Invalid data, violated business rule, missing input | App crash, timeout, selector not found, network error |
+| **Will retry fix it?** | **NO** — the data is bad, retrying produces the same result | **MAYBE** — transient issue may resolve on retry |
+| **Action** | Skip transaction, log reason, mark Failed | Retry (up to limit), reinitialize apps, then escalate |
+| **REFramework** | Caught → Failed status, no retry, next item | Caught → retry counter incremented, reinitialize apps |
+
+### When to Throw BusinessRuleException
+
+Throw `BusinessRuleException` when the input data is invalid and no amount of retrying will fix it:
+
+1. Missing required fields: `If String.IsNullOrEmpty(invoiceNumber) Then Throw New BusinessRuleException("Invoice number is empty")`
+2. Data format violations: negative amounts, invalid dates, unrecognized codes
+3. Business rule failures: amount exceeds threshold, duplicate record, expired deadline
+4. Missing dependencies: referenced record not found in target system
+
+### When to Let System Exceptions Propagate
+
+Do NOT catch these as BusinessRuleException — they are transient and may resolve on retry:
+
+1. `SelectorNotFoundException` — UI element not found (app may not be ready)
+2. `TimeoutException` — activity exceeded timeout (network lag, slow app)
+3. `System.Net.WebException` — HTTP/network failure
+4. `System.IO.IOException` — file locked by another process
+5. `COMException` — Excel/Word COM automation failure
+
+---
+
+## 2. TryCatch Best Practices
+
+### Rule: Order Catch Clauses from Specific to General
+
+The first matching catch clause executes. If `System.Exception` is first, it catches everything — more specific clauses below it never execute.
+
+```
+Try
+  ├── [Business logic activities]
+Catch ex As BusinessRuleException          ← 1. Most specific
+  ├── Log Message (Warning): "Business error: " + ex.Message
+  ├── [Skip item, mark as business exception]
+Catch ex As System.TimeoutException        ← 2. Specific system error
+  ├── Log Message (Error): "Timeout: " + ex.Message
+  ├── [Retry with longer timeout or escalate]
+Catch ex As System.Exception               ← 3. Catch-all (ALWAYS last)
+  ├── Log Message (Error): "System error: " + ex.Message
+  ├── [Retry, reinitialize apps, or escalate]
+Finally
+  ├── [Cleanup: Kill Process for COM apps, close connections]
+```
+
+### Rules
+
+1. **ALWAYS put `System.Exception` last** — it catches everything, so specific clauses must come first
+2. **NEVER use empty catch blocks** — at minimum, log the exception. Silent failures are debugging nightmares.
+3. **Use Finally for cleanup** — Kill Process for Excel/Word COM objects, close database connections, delete temp files
+4. **Don't nest TryCatch more than 2 levels** — extract inner logic to sub-workflows with their own TryCatch
+
+---
+
+## 3. Retry Scope
+
+The Retry Scope activity retries a block of activities when a condition is not met or an exception occurs.
+
+### Configuration
+
+| Property | Description | Recommended Value |
+|---|---|---|
+| `NumberOfRetries` | Max retry attempts | 2-3 for UI actions, 3-5 for network calls |
+| `RetryInterval` | Wait between retries (TimeSpan) | `00:00:03` to `00:00:10` |
+
+### Structure
+
+```
+Retry Scope (NumberOfRetries=3, RetryInterval=00:00:05)
+  ├── Action: [Activities to retry]
+  │   └── Click "Submit" button
+  └── Condition: Element Exists "Success message"
+```
+
+### Rules
+
+1. **ALWAYS add a Condition activity** — without it, Retry Scope only retries on exception. The Condition checks whether the action actually succeeded (e.g., Element Exists, text appeared, file was created).
+2. **Keep actions idempotent** — the action block runs multiple times. Clicking "Submit" twice must not create duplicate records. If the action is not idempotent, check state before acting.
+3. **Set reasonable intervals** — too short (< 1 second) wastes CPU; too long (> 30 seconds) wastes time. Match the interval to how long the system typically needs to recover.
+
+### When to Use Which Retry Mechanism
+
+| Mechanism | Use When | Scope |
+|---|---|---|
+| **Retry Scope** | Single action needs retry with success check (e.g., click button, wait for result) | One activity or small block |
+| **REFramework retry** | Entire transaction needs retry after app reinitialization | Full transaction lifecycle |
+| **Manual retry loop** | Custom retry logic with backoff, conditional retry, different strategies per attempt | Complex scenarios |
+
+---
+
+## 4. ContinueOnError Decision Matrix
+
+`ContinueOnError` suppresses exceptions from an activity. When `True`, the activity fails silently and the workflow continues.
+
+### Activities That Default to TRUE (Dangerous)
+
+| Activity | Package | Risk |
+|---|---|---|
+| `HttpClient` (HTTP Request) | Web | HTTP 500/timeout → empty response, no error raised |
+| `Data Scraping` output | UIAutomation | Extraction failure → empty DataTable, no error raised |
+
+**ALWAYS set `ContinueOnError=False`** on these activities unless you explicitly handle empty results.
+
+### When ContinueOnError=True Is Acceptable
+
+| Scenario | Why It's OK |
+|---|---|
+| `Element Exists` / `Image Exists` | Activity returns Boolean — it never throws, ContinueOnError is irrelevant |
+| Non-critical Log Message | Logging failure should not stop the automation |
+| Optional cleanup in Finally block | Best-effort cleanup (e.g., close dialog that may not exist) |
+
+### When ContinueOnError=True Is NEVER Acceptable
+
+1. **HTTP Request** — you MUST know if the API call failed
+2. **Database operations** — silent SQL failures corrupt data
+3. **File write operations** — silent write failures mean data loss
+4. **Any activity whose output you use downstream** — silent failure → null/empty → downstream crash
+5. **Library workflows** — consumers cannot know which errors are swallowed. ALWAYS let exceptions propagate from libraries.
+
+---
+
+## 5. Throw and Rethrow Patterns
+
+### Throw — Create a New Exception
+
+Use `Throw` to signal a business rule violation or intentional failure:
+
+```xml
+<!-- Simple message -->
+<Throw Exception="[New BusinessRuleException(&quot;Invoice amount is negative&quot;)]" />
+
+<!-- With variable (recommended for complex messages) -->
+<!-- Step 1: Assign errorMsg = "Invalid: " & amount.ToString("F2") & " for " & txId -->
+<!-- Step 2: Throw with variable -->
+<Throw Exception="[New BusinessRuleException(errorMsg)]" />
+```
+
+**Rules:**
+1. **Use short-form class names** — `BusinessRuleException` not `UiPath.Core.Activities.BusinessRuleException`
+2. **Build complex messages in a variable first** — avoids VB.NET compiler issues with `&quot;` in `Throw.Exception`
+3. **Include context in the message** — "Invoice INV-12345 amount -500.00 is negative" not "Invalid amount"
+
+See [common-pitfalls.md](./common-pitfalls.md) for the full Throw expression escaping reference.
+
+### Rethrow — Preserve Original Stack Trace
+
+Use `Rethrow` inside a Catch block when you want to log/handle but still propagate the exception:
+
+```
+Catch ex As System.Exception
+  ├── Log Message: "Error in ProcessInvoice: " + ex.Message
+  ├── Take Screenshot
+  └── Rethrow   ← preserves original exception type and stack trace
+```
+
+**When to Rethrow:**
+- You need to log or screenshot before propagating
+- You're in a sub-workflow and the caller handles the exception
+- You want to add cleanup but still fail the transaction
+
+**When NOT to Rethrow:**
+- You've fully handled the exception (e.g., used a fallback value)
+- You're wrapping in a different exception type (use Throw instead)
+
+---
+
+## 6. Finally Block Patterns
+
+The Finally block runs regardless of whether an exception occurred. Use it for mandatory cleanup.
+
+### Common Cleanup Patterns
+
+| Scenario | Finally Action |
+|---|---|
+| Excel COM automation | Kill Process "EXCEL" — prevents zombie EXCEL.EXE processes after crashes |
+| Word COM automation | Kill Process "WINWORD" |
+| Database connection | Close connection activity or Dispose in InvokeCode |
+| Temp files created | Delete File for each temp file |
+| Browser opened | Close Tab / Close Browser |
+| Application opened | Close Application |
+
+### Rules
+
+1. **Kill Process in Finally for COM apps** — Excel Application Scope and Word Application Scope can leave zombie processes if the workflow crashes mid-execution
+2. **Don't put business logic in Finally** — Finally is for cleanup only
+3. **Use ContinueOnError=True in Finally cleanup** — if the process is already dead, Kill Process throws; this is acceptable to ignore
+
+---
+
+## 7. Fail-Fast Principle
+
+Validate inputs at the beginning of a workflow. Throw `BusinessRuleException` immediately when data is invalid — don't process halfway then fail.
+
+### Input Validation Pattern
+
+Place this at the START of `Process.xaml` (or any workflow that receives arguments):
+
+```
+Sequence "Validate Inputs"
+  ├── If String.IsNullOrWhiteSpace(in_InvoiceNumber)
+  │   └── Throw New BusinessRuleException("Invoice number is empty")
+  ├── If in_Amount <= 0
+  │   └── Throw New BusinessRuleException("Amount must be positive: " & in_Amount.ToString())
+  ├── If Not DateTime.TryParse(in_DateString, Nothing)
+  │   └── Throw New BusinessRuleException("Invalid date format: " & in_DateString)
+  └── [Continue with validated data]
+```
+
+### Rules
+
+1. **Validate ALL required inputs before processing** — catch all problems upfront, not one at a time
+2. **Include the invalid value in the error message** — "Amount -500.00 is negative" not "Invalid amount"
+3. **Use BusinessRuleException for validation failures** — the data is bad, retrying won't help
+4. **Don't validate inside loops** — validate once before the loop starts
+
+---
+
+## 8. State Machine Exit Conditions
+
+When building State Machine workflows (including REFramework customizations):
+
+1. **Every state machine MUST have a reachable Final State** — a state with no outgoing transitions that ends execution
+2. **Every state MUST have at least one outgoing transition** (except the Final State) — orphan states cause infinite hangs
+3. **Add a default/fallback transition** from every decision state — handles unexpected conditions
+4. **Limit transitions per state to 3-4** — more indicates the state is doing too much; split it
+5. **Set max-retry counters** — any retry loop must have a counter that eventually routes to the Final State
+6. **Test the "all failures" path** — verify that if every transaction fails, the robot reaches End Process (not infinite loop)
+
+### REFramework-Specific
+
+The REFramework already handles exit conditions via `MaxRetryNumber` and `MaxConsecutiveSystemExceptions`. When customizing:
+
+- **Do NOT remove the ConsecutiveSystemExceptions check** — it's the safety net that prevents infinite retries when the environment is broken
+- **Do NOT set MaxRetryNumber to 0** — this disables retry entirely; use 1 if you want minimal retry
+- **Do NOT add states without transitions to End Process** — every custom state needs a failure path that reaches the Final State

package/skills/uipath-rpa/references/legacy/legacy-mode-guide.md

@@ -0,0 +1,255 @@
+# Legacy RPA Workflow Architect
+
+> **Preview** — legacy mode is under active development; surface and behavior may change.
+
+Entry point for the **Legacy** target framework of `uipath-rpa`. Use this guide when `project.json` has `targetFramework: "Legacy"` (or the field is absent — Legacy is the default for older projects).
+
+Legacy UiPath RPA projects: .NET Framework 4.6.1, VB.NET expressions, classic activities (no "X" suffix). Uses `uip rpa-legacy` CLI (standalone, no Studio IPC needed).
+
+## Critical Rules
+
+1. **Discover before writing** — for built-in activities (If, Assign, TryCatch, LogMessage, etc.), use XAML from `_BUILT-IN-ACTIVITIES.md` directly. For all others, run `find-activities` + `type-definition` first.
+2. **Validate frequently** — for Sequences with well-known activities, write the full XAML then validate once. For Flowcharts/StateMachines/unfamiliar activities, validate after each addition. Always validate after edits to existing files.
+3. **Absolute paths only** — store `{projectRoot}` as an absolute path at Phase 0. Pass it to every CLI command. **Never use `cd`.**
+4. **Fix by category** — Package → Structure → Type → Properties → Logic. This order prevents cascading errors.
+5. **Activity docs for gotchas, CLI for precision** — read package docs (Excel.md, Mail.md) for gotchas before using those packages. Run `find-activities` only for activities not in `_BUILT-IN-ACTIVITIES.md`.
+6. **Always use `--output json`** — for any CLI output you need to parse. **Never suppress stderr** (`2>/dev/null`) — error details are in the JSON output.
+7. **Never guess enum values or property names** — always use `find-activities` + `type-definition`. CLI discovery is mandatory for valid XAML.
+8. **Never use modern assemblies** — use `assembly=mscorlib` (not `System.Private.CoreLib`). Use `[bracket]` expressions in VB.NET projects, `<mca:CSharpValue>` in C# projects.
+9. **Never generate Flowchart/StateMachine without ViewState** — Studio stacks all nodes at (0,0) without it.
+10. **Never retry failing CLI commands blindly** — diagnose the root cause before retrying.
+11. **Probe the `rpa-legacy` packaging verb once per session, before the first pack.** Run `uip rpa-legacy pack --help --output json`. Result `Success` → use `pack` (post-rename, default). `unknown command` / non-zero exit → CLI predates the closed-verb-set rename; use `uip rpa-legacy package` instead with the same arguments and flags. Both surfaces produce the same `.nupkg`.
+
+---
+
+## Request Router
+
+| Request | Action | Key Reference |
+|---------|--------|---------------|
+| Choose architecture | Sequence vs REFramework vs Dispatcher/Performer | [project-organization-guide.md](./project-organization-guide.md) |
+| Create workflow | Phase 0 → Discovery → Generate | [xaml-basics-and-rules.md](./xaml-basics-and-rules.md) |
+| Edit workflow | Phase 0 → Discovery → Edit | [xaml-basics-and-rules.md](./xaml-basics-and-rules.md) |
+| Validate file | `uip rpa-legacy validate "{projectRoot}/File.xaml" --output json` | [validation-and-fixing.md](./validation-and-fixing.md) |
+| Validate project | `uip rpa-legacy validate "{projectRoot}" --output json` | [validation-and-fixing.md](./validation-and-fixing.md) |
+| Package (optional) | `uip rpa-legacy pack "{projectRoot}" -o "{dir}"` | [cli-reference.md](./cli-reference.md) |
+| Debug | `uip rpa-legacy debug "{projectRoot}/File.xaml"` | [cli-reference.md](./cli-reference.md) |
+| Create new project | Create project.json with right packages | [project-structure.md](./project-structure.md) |
+| Create test data | Generate Excel/CSV/JSON/types for testing | [test-data-guide.md](./test-data-guide.md) |
+| Organize project | Folder structure, naming, libraries | [project-organization-guide.md](./project-organization-guide.md) |
+| Add error handling | TryCatch, Retry Scope, exception classification | [error-handling-guide.md](./error-handling-guide.md) |
+| Fix/build selectors | Selector anatomy, dynamic selectors, anchors | [selector-guide.md](./selector-guide.md) |
+| Create tests | Test design, mock testing, verification | [testing-guide.md](./testing-guide.md) |
+
+If unclear which file to edit, **ask the user**.
+
+---
+
+## Phase 0: Environment
+
+1. Find `project.json` → establish `{projectRoot}` **as absolute path**
+2. Read `project.json` → verify `targetFramework: "Legacy"` (or absent = Legacy)
+3. Note `expressionLanguage` (VB.NET or C#)
+4. Note project shape: count `.xaml` files, list `dependencies` keys and versions — use this to avoid re-discovering packages and activities already explored earlier in conversation
+5. Run `uip rpa-legacy validate "{projectRoot}" --output json` to trigger **package restore** (required before `find-activities` works)
+
+No Studio needed. See [environment-setup.md](./environment-setup.md) for details.
+
+---
+
+## Phase 1: Discovery
+
+**Start with the minimum. Add more only as needed.**
+
+1. Read [_BUILT-IN-ACTIVITIES.md](./activity-docs/_BUILT-IN-ACTIVITIES.md) — complete XAML for If, Assign, Sequence, TryCatch, ForEach, While, Switch, Throw, LogMessage, InvokeCode, ForEachRow, etc. **No CLI calls needed for these.**
+
+2. Read [xaml-basics-and-rules.md](./xaml-basics-and-rules.md) — XAML structure, baseline assembly references, safety rules.
+
+3. **Only if you need non-built-in activities** (Excel, Mail, HTTP, PDF, etc.):
+   - Run `find-activities "{projectRoot}" --query "..." --output json` for each — use returned `XamlSnippet`
+   - Run `type-definition` for any enums in the results
+   - Read the relevant package doc ([Excel.md](./activity-docs/Excel.md), [Mail.md](./activity-docs/Mail.md), etc.) for gotchas
+
+4. **Only if Flowchart/StateMachine**: read [_XAML-GUIDE.md](./activity-docs/_XAML-GUIDE.md) for ViewState layout
+
+**Stop here.** Don't read more files unless you hit a problem during validation. Additional references if needed: [_PATTERNS.md](./activity-docs/_PATTERNS.md) (VB.NET expressions), [common-pitfalls.md](./common-pitfalls.md) (gotchas), [_INVOKE-CODE.md](./activity-docs/_INVOKE-CODE.md) (InvokeCode details), [_REFRAMEWORK.md](./activity-docs/_REFRAMEWORK.md) (REFramework), `uip docsai ask "..."` (official docs), `WebSearch` (community).
+
+5. **If the task involves design decisions**, read the relevant guide on demand:
+   - Error handling strategy → [error-handling-guide.md](./error-handling-guide.md)
+   - UI selectors → [selector-guide.md](./selector-guide.md)
+   - Project structure / libraries → [project-organization-guide.md](./project-organization-guide.md)
+   - Advanced data manipulation (RegEx, LINQ, JObject) → [data-manipulation-guide.md](./data-manipulation-guide.md)
+   - Orchestrator integration (queues, assets, triggers) → [orchestrator-guide.md](./orchestrator-guide.md)
+   - Test design / debugging → [testing-guide.md](./testing-guide.md)
+
+See [discovery-workflow.md](./discovery-workflow.md) for the full step-by-step procedure.
+
+---
+
+## Phase 2: Generate or Edit
+
+### Before Writing ANY XAML
+
+- [ ] Read relevant activity doc (behavioral context)
+- [ ] Run `find-activities` for every activity — use returned `XamlSnippet` + `XmlnsDeclaration` as starting point
+- [ ] Run `type-definition` for every enum/complex type (exact values)
+- [ ] Read [xaml-basics-and-rules.md](./xaml-basics-and-rules.md) for XAML structure
+- [ ] Read [common-pitfalls.md](./common-pitfalls.md) for gotchas
+
+### Choose Workflow Type
+
+| Pattern | Use When |
+|---------|----------|
+| **Sequence** | Linear step-by-step, no branching |
+| **Flowchart** | Branching decisions, loops with conditions, complex control flow |
+| **StateMachine** | Distinct states with transitions (REFramework, approval workflows) |
+
+### Flowchart/StateMachine: Plan Layout FIRST
+
+Before writing XAML for Flowchart or StateMachine:
+1. List all nodes and connections
+2. Assign coordinates per layout guide in [_XAML-GUIDE.md](./activity-docs/_XAML-GUIDE.md)
+3. Map True/False branch paths (Flowchart) or transition routes (StateMachine)
+
+**ViewState is MANDATORY** — without it, Studio stacks all nodes at (0,0).
+
+### CREATE Checklist
+
+- [ ] Root `<Activity>` has `mva:VisualBasic.Settings="{x:Null}"` (VB projects)
+- [ ] xmlns uses `assembly=mscorlib` (not `System.Private.CoreLib`)
+- [ ] VB.NET: `[bracket]` notation for expressions
+- [ ] Classic activity names (no "X" suffix)
+- [ ] All 16 baseline assembly references present (see [xaml-basics-and-rules.md](./xaml-basics-and-rules.md))
+- [ ] All 21 baseline namespace imports present
+- [ ] Package-specific assembly refs + namespace imports added for every activity package used
+- [ ] Flowchart/StateMachine: `xmlns:av` declared, ViewState on every node
+- [ ] Scope activities: `ActivityAction<T>` body pattern (see [common-pitfalls.md](./common-pitfalls.md))
+
+### EDIT Checklist
+
+- [ ] Read current XAML content before editing
+- [ ] Use `Edit` tool with exact `old_string` match
+- [ ] Flowchart/StateMachine: read existing ViewState positions, place new nodes with ≥110px vertical / ≥200px horizontal clearance
+- [ ] Validate after every edit
+
+---
+
+## Phase 3: Validate & Fix
+
+```
+LOOP (per-file during iteration):
+  validate "{projectRoot}/File.xaml" → 0 errors? → next activity
+                                     → errors?   → categorize → fix → validate again
+
+FINAL (before completing):
+  validate "{projectRoot}" → 0 errors across entire project? → DONE
+```
+
+**Fix order:** Package → Structure → Type → Properties → Logic
+
+| Category | Fix Strategy |
+|----------|-------------|
+| **Package** | Ask user to install in Studio (no CLI install command) |
+| **Structure** | Read XAML around error → Edit to fix XML |
+| **Type** | `type-definition` for exact enum/type values |
+| **Properties** | `find-activities --include-type-definitions` for exact property names |
+| **Logic** | Check expression language, consult `_PATTERNS.md`, use `debug` |
+
+When stuck: `docsai ask` → `WebSearch` → ask user.
+
+See [validation-and-fixing.md](./validation-and-fixing.md) for detailed procedures and common error scenarios.
+
+---
+
+## Phase 4: Debug
+
+**Only when the user asks to test/run the workflow.** Do not auto-trigger. Suggest it after completing validation: _"Would you like me to run the workflow to test it?"_
+
+**Always validate before debugging** — don't debug a file with compilation errors.
+
+```bash
+# Basic execution
+uip rpa-legacy debug "{projectRoot}/Main.xaml"
+
+# With input arguments
+uip rpa-legacy debug "{projectRoot}/Main.xaml" -i '{"in_FilePath": "C:\\data.xlsx", "in_Count": 5}'
+
+# Capture result to file
+uip rpa-legacy debug "{projectRoot}/Main.xaml" -i '{"in_FilePath": "C:\\data.xlsx"}' --result-path /tmp/result.json --log-level error
+```
+
+**Reading results:**
+- Exit code 0 → success: read `Data.Output` for out-argument values
+- Exit code 1 → failure: read `Data.Error` for diagnostics:
+  - `Error.ActivityDisplayName` + `Error.XamlFile` → locate the problem
+  - `Error.ExceptionType` + `Error.Message` → understand it
+  - `Error.StackTrace` → full call chain
+  - `Data.ErrorLog` → all error-level robot log entries for context
+
+**Fix-and-retry loop:** edit XAML → validate → debug again.
+
+See [cli-reference.md](./cli-reference.md) for all options.
+
+---
+
+## Phase 5: Response Checklist
+
+- [ ] File path of created/edited workflow
+- [ ] Brief description of what the workflow does
+- [ ] Key activities and logic
+- [ ] Packages required (note manual installs)
+- [ ] Per-file validation passed during development
+- [ ] Whole-project validation passed (`validate "{projectRoot}"`)
+- [ ] Limitations and next steps
+- [ ] Manual actions needed (package install, connection setup)
+
+---
+
+## Quick Reference
+
+### CLI Commands
+
+| Command | Purpose |
+|---------|---------|
+| `uip rpa-legacy find-activities <path> --query "..." [--exact] --output json` | Find activities, class names, arguments, **XAML snippet, xmlns** |
+| `uip rpa-legacy type-definition <path> --type "..." --output json` | Inspect types, enum values, properties |
+| `uip rpa-legacy validate <file-or-project-path> --output json` | Validate single file or entire project |
+| `uip rpa-legacy find-package --query "..." --output json` | Search NuGet feeds for packages |
+| `uip rpa-legacy pack <path> -o <dir>` | Package into .nupkg (optional) |
+| `uip rpa-legacy debug <xaml-path> -i '...'` | Execute via UiRobot |
+| `uip docsai ask "question" --output json` | Search UiPath documentation |
+
+Full reference: [cli-reference.md](./cli-reference.md)
+
+### Reference Files
+
+| File | Content |
+|------|---------|
+| [cli-reference.md](./cli-reference.md) | All CLI commands, parameters, error recovery |
+| [discovery-workflow.md](./discovery-workflow.md) | Detailed discovery steps, troubleshooting |
+| [environment-setup.md](./environment-setup.md) | Project root detection, legacy verification |
+| [project-structure.md](./project-structure.md) | Legacy project layout, project.json schema |
+| [xaml-basics-and-rules.md](./xaml-basics-and-rules.md) | XAML anatomy, expressions, safety rules |
+| [common-pitfalls.md](./common-pitfalls.md) | Dangerous defaults, scope patterns, gotchas |
+| [validation-and-fixing.md](./validation-and-fixing.md) | Validate & fix loop, error scenarios |
+| [test-data-guide.md](./test-data-guide.md) | Excel, CSV, JSON, top 10 file types and UiPath types |
+| [error-handling-guide.md](./error-handling-guide.md) | Exception classification, TryCatch patterns, Retry Scope, ContinueOnError |
+| [selector-guide.md](./selector-guide.md) | Selector anatomy, dynamic selectors, anchors, validation checklist |
+| [project-organization-guide.md](./project-organization-guide.md) | Folder conventions, naming, Config.xlsx, libraries, single responsibility |
+| [data-manipulation-guide.md](./data-manipulation-guide.md) | RegEx, advanced LINQ, JObject/JArray, StringBuilder, type conversions |
+| [orchestrator-guide.md](./orchestrator-guide.md) | Queue lifecycle, asset types, logging levels, triggers, environments |
+| [testing-guide.md](./testing-guide.md) | Test design, verification activities, mock testing, debugging strategy |
+
+### Activity Docs (`./activity-docs/`)
+
+| File | Content |
+|------|---------|
+| `_BUILT-IN-ACTIVITIES.md` | **Top 20 activities with complete XAML — no find-activities needed** |
+| `_INDEX.md` | Master index with adoption rankings |
+| `_PATTERNS.md` | VB.NET cheat sheet, DataTable ops, error handling |
+| `_XAML-GUIDE.md` | XAML internals, Flowchart/StateMachine layout guides |
+| `_COMMON-PITFALLS.md` | Real-world gotchas by package |
+| `_INVOKE-CODE.md` | InvokeCode: properties, templates, compilation |
+| `_REFRAMEWORK.md` | REFramework template structure and customization |
+| `_DU-PROCESS.md` | Document Understanding pipeline template |
+| `AllActivities.md` | Complete legacy activity catalog |
+| `{Package}.md` | Per-package docs (Excel, Mail, System, UIAutomation, etc.) |