@uipath/skills 1.199.0 → 1.200.0

package/skills/uipath-rpa/assets/codedworkflow-template.md

@@ -1,8 +1,8 @@
-# UiPath Coded Workflow Templates
+# UiPath Coded Templates (Workflows, Test Cases, Helpers, Hooks)
 
-Ready-to-use templates for UiPath coded workflow files. Replace placeholders in `{{PLACEHOLDER}}` format.
+Ready-to-use templates for UiPath coded files — workflows, test cases, helper/utility classes, and Before/After hooks. Replace placeholders in `{{PLACEHOLDER}}` format.
 
-> **Using statements:** These templates include only the minimal required usings. Add service-specific usings based on actual usage — see [coding-guidelines.md](../references/coded/coding-guidelines.md) for the full mapping.
+> **Using statements:** These templates include only the minimal required usings. Add service-specific usings based on actual usage — see [operations-guide.md § Coding Guidelines](../references/coded/operations-guide.md#coding-guidelines) for the full mapping.
 
 ---
 
@@ -12,7 +12,7 @@ Ready-to-use templates for UiPath coded workflow files. Replace placeholders in
 using System;
 using System.Collections.Generic;
 using UiPath.CodedWorkflows;
-// Add service-specific usings as needed — see references/coding-guidelines.md
+// Add service-specific usings as needed — see operations-guide.md § Using Statements Rules
 
 namespace {{PROJECT_NAME}}
 {
@@ -33,7 +33,7 @@ namespace {{PROJECT_NAME}}
 using System;
 using System.Collections.Generic;
 using UiPath.CodedWorkflows;
-// Add service-specific usings as needed — see references/coding-guidelines.md
+// Add service-specific usings as needed — see operations-guide.md § Using Statements Rules
 
 namespace {{PROJECT_NAME}}
 {
@@ -55,7 +55,7 @@ namespace {{PROJECT_NAME}}
 using System;
 using System.Collections.Generic;
 using UiPath.CodedWorkflows;
-// Add service-specific usings as needed — see references/coding-guidelines.md
+// Add service-specific usings as needed — see operations-guide.md § Using Statements Rules
 
 namespace {{PROJECT_NAME}}
 {
@@ -79,7 +79,7 @@ A single input argument named `Output` with the same type as the return value be
 using System;
 using System.Collections.Generic;
 using UiPath.CodedWorkflows;
-// Add service-specific usings as needed — see references/coding-guidelines.md
+// Add service-specific usings as needed — see operations-guide.md § Using Statements Rules
 
 namespace {{PROJECT_NAME}}
 {
@@ -103,7 +103,7 @@ When multiple arguments are both input and output, the return type must be a tup
 using System;
 using System.Collections.Generic;
 using UiPath.CodedWorkflows;
-// Add service-specific usings as needed — see references/coding-guidelines.md
+// Add service-specific usings as needed — see operations-guide.md § Using Statements Rules
 
 namespace {{PROJECT_NAME}}
 {
@@ -126,7 +126,7 @@ using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
 using UiPath.CodedWorkflows;
-// Add service-specific usings as needed — see references/coding-guidelines.md
+// Add service-specific usings as needed — see operations-guide.md § Using Statements Rules
 
 namespace {{PROJECT_NAME}}
 {
@@ -145,11 +145,16 @@ namespace {{PROJECT_NAME}}
 
 Parameters with default values become **optional** when the workflow is invoked via `workflows.MyWorkflow()` — callers can omit them to use the defaults, or pass explicit values to override.
 
+Three rules for default values:
+1. **Self-contained compile-time literals only** — a default referencing a class const/field fails codegen with `CS0103` in the generated activity wrapper.
+2. **`--input-arguments key=` (empty value) overrides the default with `""`** — omit the flag entirely to use the declared default.
+3. **No machine-specific absolute paths as defaults** — accept paths as arguments and resolve them relative to the run-time working directory.
+
 ```csharp
 using System;
 using System.Collections.Generic;
 using UiPath.CodedWorkflows;
-// Add service-specific usings as needed — see references/coding-guidelines.md
+// Add service-specific usings as needed — see operations-guide.md § Using Statements Rules
 
 namespace {{PROJECT_NAME}}
 {
@@ -183,4 +188,233 @@ workflows.LaunchApp(browser: "msedge.exe");
 
 // Override both
 workflows.LaunchApp(browser: "msedge.exe", retryCount: 5);
-```
+```
+
+---
+
+## Coded Test Case Templates
+
+
+### Coded Test Case (.cs) — Basic
+
+```csharp
+using System;
+using System.Collections.Generic;
+using UiPath.CodedWorkflows;
+// Add service-specific usings as needed — see operations-guide.md § Using Statements Rules
+
+namespace {{PROJECT_NAME}}
+{
+    public class {{CLASS_NAME}} : CodedWorkflow
+    {
+        [TestCase]
+        public void Execute()
+        {
+            // Arrange
+            {{ARRANGE}}
+
+            // Act
+            {{ACT}}
+
+            // Assert
+            testing.VerifyExpression({{ASSERTION}});
+        }
+    }
+}
+```
+
+### Coded Test Case (.cs) — Data-Driven with Default Parameters
+
+```csharp
+using System;
+using System.Collections.Generic;
+using UiPath.CodedWorkflows;
+// Add service-specific usings as needed — see operations-guide.md § Using Statements Rules
+
+namespace {{PROJECT_NAME}}
+{
+    public class {{CLASS_NAME}} : CodedWorkflow
+    {
+        [TestCase]
+        public void Execute(System.String {{paramName}} = "{{defaultValue}}")
+        {
+            // Arrange
+            {{ARRANGE}}
+
+            // Act
+            {{ACT}}
+
+            // Assert
+            testing.VerifyExpression({{ASSERTION}});
+        }
+    }
+}
+```
+
+### Coded Test Case (.cs) — Data-Driven with Test Data Queue
+
+```csharp
+using System;
+using System.Collections.Generic;
+using UiPath.CodedWorkflows;
+// Add service-specific usings as needed — see operations-guide.md § Using Statements Rules
+
+namespace {{PROJECT_NAME}}
+{
+    public class {{CLASS_NAME}} : CodedWorkflow
+    {
+        [TestCase]
+        public void Execute()
+        {
+            // Arrange — get test data from queue
+            var item = testing.GetTestDataQueueItem("{{QUEUE_NAME}}");
+            {{EXTRACT_FIELDS}}
+
+            // Act
+            {{ACT}}
+
+            // Assert
+            testing.VerifyExpression({{ASSERTION}});
+        }
+    }
+}
+```
+
+---
+
+## Helper/Utility Class Templates
+
+### Helper/Utility Class (.cs) — No Attribute
+
+```csharp
+using System;
+using System.Collections.Generic;
+
+namespace {{PROJECT_NAME}}
+{
+    public class {{CLASS_NAME}}
+    {
+        {{IMPLEMENTATION}}
+    }
+}
+```
+
+IMPORTANT!: Helper classes do NOT inherit from `CodedWorkflow`, do NOT have `[Workflow]` or `[TestCase]` attributes. They are NOT entry points and do not appear in the fileInfoCollection attribute from `project.json`.
+
+---
+
+## Before/After Hooks Templates
+
+### IBeforeAfterRun on Individual Workflow/Test Case
+
+**File: `TestLoginFlow.cs`**
+
+```csharp
+using UiPath.CodedWorkflows;
+
+namespace {{PROJECT_NAME}}
+{
+    public class TestLoginFlow : CodedWorkflow, IBeforeAfterRun
+    {
+        public void Before(BeforeRunContext context)
+        {
+            Log($"[BEFORE] Starting {context.RelativeFilePath}");
+            // Open browser, navigate to login page
+        }
+
+        public void After(AfterRunContext context)
+        {
+            Log($"[AFTER] Finished {context.RelativeFilePath}");
+            // Close browser, clean up
+        }
+
+        [TestCase]
+        public void Execute()
+        {
+            // Before() has already run
+
+            // Arrange
+            string username = "testuser";
+
+            // Act
+            var result = workflows.Login(username: username, password: "pass123");
+
+            // Assert
+            testing.VerifyExpression(result.success, "Login should succeed");
+
+            // After() will run automatically
+        }
+    }
+}
+```
+
+### Partial Class CodedWorkflow — Hooks for ALL Files
+
+**File: `CodedWorkflowHooks.cs`** (Coded Source File — NOT a workflow, no entry point)
+
+```csharp
+using UiPath.CodedWorkflows;
+
+namespace {{PROJECT_NAME}}
+{
+    public partial class CodedWorkflow : IBeforeAfterRun
+    {
+        public void Before(BeforeRunContext context)
+        {
+            Log($"[BEFORE] Execution started for {context.RelativeFilePath}");
+
+            // Example: Open application
+            // var app = uiAutomation.Open("myApp");
+
+            // Example: Log in
+            // Login("testuser", "password");
+        }
+
+        public void After(AfterRunContext context)
+        {
+            Log($"[AFTER] Execution finished for {context.RelativeFilePath}");
+
+            // Example: Close application
+            // uiAutomation.Close(app);
+
+            // Example: Clean up test data
+            // DeleteTestData();
+        }
+    }
+}
+```
+
+### Partial Class CodedWorkflow — Shared Logic (Without Hooks)
+
+**File: `CodedWorkflowExtensions.cs`** (Coded Source File)
+
+```csharp
+using UiPath.CodedWorkflows;
+
+namespace {{PROJECT_NAME}}
+{
+    public partial class CodedWorkflow
+    {
+        // Shared helper available in all workflows and test cases
+        protected string GetEnvironmentUrl()
+        {
+            var env = system.GetAsset("Environment").ToString();
+            return env == "prod" ? "https://app.example.com" : "https://staging.example.com";
+        }
+
+        // Shared constant
+        protected const int MaxRetries = 3;
+    }
+}
+```
+
+### Usage in Any Workflow
+
+```csharp
+[Workflow]
+public void Execute()
+{
+    string url = GetEnvironmentUrl();  // available via partial class
+    Log($"Using environment: {url}");
+}
+```

package/skills/uipath-rpa/references/cli-reference.md

@@ -124,6 +124,7 @@ Rules:
 - **`=` vs `:=`**: `count=42` sends the string `"42"`; `count:=42` sends the number `42`. For `debug test-activity` / `debug start-from-here`, values are VB/C# expression **strings** — always `=`.
 - **Quoting**: single-quote any token containing spaces, commas, or a leading `@`; bare identifiers and numbers need no quotes. Values containing double quotes cannot be passed inline on Windows PowerShell 5.1 (it strips them) — write them to a UTF-8 file (`Set-Content -Encoding UTF8`) and use `key=@file`, `'@file'`, or `--<flag>-file`.
 - **Inline JSON**: a single JSON blob (`--input-arguments '{"k":"v"}'`) remains accepted for backward compatibility, but is unreliable on PowerShell 5.1 — prefer pairs or files.
+- **Empty value ≠ default**: `--input-arguments key=` passes an empty string, which OVERRIDES a coded workflow's declared default parameter value. Omit the flag entirely to use the default.
 
 ---
 
@@ -137,7 +138,7 @@ Rules:
 
 ## build
 
-`uip rpa build` compiles the project — catching runtime-compile failures `validate` misses (including attribute-form expression failures like `JIT compilation is disabled for non-Legacy projects` in C#-expression XAML projects). Required before returning a project to the user (see [validation-guide.md § Project Build Verification](validation-guide.md#project-build-verification-required-before-returning-a-project)). Takes the project directory as a **positional** argument and runs independently of Studio IPC. Discover flags (log level, skip-analyze, governance, NuGet sources) via `uip rpa build --help`.
+`uip rpa build` compiles the project — catching runtime-compile failures `validate` misses (including attribute-form expression failures like `JIT compilation is disabled for non-Legacy projects` in C#-expression XAML projects). Required before returning a project to the user (see [§ Project Build Verification](#project-build-verification-required-before-returning-a-project)). Takes the project directory as a **positional** argument and runs independently of Studio IPC. Discover flags (log level, skip-analyze, governance, NuGet sources) via `uip rpa build --help`.
 
 `run` and `debug start` compile internally, so a successful smoke test implies `build` would pass. When no smoke test runs (side effects, interactive workflow, no test input), `build` is the required compilability check.
 
@@ -145,9 +146,9 @@ Rules:
 
 ## analyzer-rules list
 
-`uip rpa analyzer-rules list` reports the Workflow Analyzer rules **enabled** for the project — the best-practice rules `validate` and `build` enforce. Reports rules, not violations. Each rule returns `severity` (`error`/`warning`/`info`), rule ID, scope, title, and (when available) `recommendation` and `docs` URL. Prefix convention: `ST-*` = built-in Studio rule, `MA-*` = package-shipped rule.
+`uip rpa analyzer-rules list` reports the Workflow Analyzer rules **enabled** for the project — the best-practice rules `validate` and `build` enforce. Reports rules, not violations. Do NOT run it as an authoring prerequisite — `validate`/`build` already enforce the rules and report violations with rule IDs and recommendations. Run it **only on demand**: (1) the user asks about the project's best-practice / analyzer rules, or (2) repeated violations of the same rule family across `validate`/`build` iterations suggest authoring against the full rule set. Each rule returns `severity` (`error`/`warning`/`info`), rule ID, scope, title, and (when available) `recommendation` and `docs` URL. Prefix convention: `ST-*` = built-in Studio rule, `MA-*` = package-shipped rule.
 
-Rules with scope `Coded Workflow` run as Roslyn analyzers over the project's `.cs` files during `analyze`, `build`, and `pack` — same enforcement as the XAML-scoped rules. The four built-in ones are all Error severity; triggers and fixes: [coded/coding-guidelines.md § Coded Workflow Analyzer Rules](coded/coding-guidelines.md#coded-workflow-analyzer-rules).
+Rules with scope `Coded Workflow` run as Roslyn analyzers over the project's `.cs` files during `analyze`, `build`, and `pack` — same enforcement as the XAML-scoped rules. The four built-in ones are all Error severity; triggers and fixes: [coded/operations-guide.md § Coded Workflow Analyzer Rules](coded/operations-guide.md#coded-workflow-analyzer-rules).
 
 > **Performance:** the unscoped call enumerates every rule across every package and can take a minute or more. Narrow with `--scope` (`Activity`, `Workflow`, `Project`, or `Coded Workflow`) — scoped calls return in seconds. See `--help` for accepted scope values.
 
@@ -208,7 +209,7 @@ Typical flow, all under `uip rpa data-fabric-entities` (discover exact flags via
 
 `uip is` manages connectors, connections, resources, triggers, and webhooks. Discover the full surface via `uip is --help`, then drill in (`uip is connections --help`, `uip is resources describe --help`, …). All verbs support `--output json`.
 
-The verbs you'll reach for: list/describe **connectors** and their **activities**/**resources**, list/create/ping/edit **connections** (OAuth opens a browser; `--no-browser` prints the URL), and run CRUD **resource** operations. For RPA-specific connector workflow patterns (activity/resource discovery, connection management, schema inspection), see [connector-capabilities.md](connector-capabilities.md).
+The verbs you'll reach for: list/describe **connectors** and their **activities**/**resources**, list/create/ping/edit **connections** (OAuth opens a browser; `--no-browser` prints the URL), and run CRUD **resource** operations. For RPA-specific connector workflow patterns (activity/resource discovery, connection management, schema inspection), see [is-connector-xaml-guide.md](is-connector-xaml-guide.md).
 
 ---
 
@@ -244,6 +245,228 @@ A `connect` / `set-default-project` / `clear-default-project` response may inclu
 
 ---
 
+## Fix One Thing at a Time
+
+When an error occurs, identify the root cause, fix **only** that one thing, and re-run.
+
+- Never bundle a speculative improvement with the actual fix.
+- Changing two things at once makes it impossible to verify which change resolved the issue or whether the extra change introduced a new one.
+- One fix per iteration, re-run, verify.
+
+## Validation Iteration Loop
+
+Phase 1 — per-file `validate` after every edit. Phase 2 — one project-level `build` per edit session.
+
+```
+PHASE 1 — validate-clean (per-file):
+  FOR each file created or edited in this session:
+    REPEAT:
+      1. uip rpa validate --file-path "<FILE>" --project-dir "<PROJECT_DIR>" --output json
+      2. IF validate has errors -> fix one root cause, GOTO 1
+      3. EXIT inner loop when validate is clean
+
+PHASE 2 — build-clean (per-project, once per edit session):
+  REPEAT:
+    1. uip rpa build "<PROJECT_DIR>" --log-level Warn --output json
+    2. IF build has errors -> identify offending file from build output
+       a. uip rpa validate --file-path "<OFFENDER>" --project-dir "<PROJECT_DIR>" --output json   # cheap targeted re-check
+       b. fix one root cause, GOTO 1
+    3. EXIT to Smoke Test
+```
+
+**Why both phases.** `validate` is static analysis: catches structural XAML, missing references, analyzer rules, schema violations. `build` is the compiler: catches **unknown member names** (e.g. `NGetText.Value` when the output member is `TextString` (or legacy `Text`)), **invalid enum values** (e.g. `Operator="StartsWith"` when the enum has no such member), **member resolution / CacheMetadata failures**, and attribute-form C# expression JIT failures. `validate` returns "no diagnostics found" for these; `build` flags them at compile time. Per-file `validate` plus one end-of-session `build` covers both error classes — trusting only `validate` ships broken workflows.
+
+**Target the specific file:** `validate --file-path` validates only the file you changed (faster than whole-project). `build` is project-scoped (no `--file-path`); when it errors, the output names the offending file — re-run `validate --file-path` on it as part of Phase 2's fix loop.
+
+**5-attempt cap per loop** — 5 attempts for each file's Phase 1 `validate` loop; a separate 5 attempts for the Phase 2 `build` loop. After a loop exhausts its budget, present the remaining errors to the user. They may require domain knowledge or environment-specific fixes. Each loop's counter resets when you start a new loop (e.g., new file, new user prompt, or resuming after user input).
+
+### Rules
+
+1. DO NOT stop until all errors are resolved (or cannot be resolved automatically).
+2. DO NOT obsess on one error -- if it cannot be resolved, skip it, continue, and defer to the user through an informative, step-by-step message at the end.
+3. DO NOT skip validation steps.
+4. DO NOT assume edits worked without checking.
+5. DO NOT bundle multiple fixes in one iteration. Fix the root cause, re-run, verify. Never add a speculative change alongside the actual fix -- changing two things at once makes it impossible to tell which one resolved the issue or whether the extra change introduced a new problem.
+6. Warnings are non-blocking. Once `validate`/`build` (and, where the task requires, `pack`/`run`) are clean of errors, deliver — do not investigate warnings unless the user asked or one blocks an acceptance criterion.
+
+Full `validate` and `run` command documentation: [§ validate](#validate) and [§ Reading run / debug results](#reading-run--debug-results).
+
+## Project Build Verification (Required Before Returning a Project)
+
+Every project returned to the user must compile. Phase 2 of the iteration loop above is this gate — when Phase 2 exits clean, the gate is satisfied. The standalone command below also satisfies it (for example, when re-verifying after a small fix outside an iteration loop):
+
+```bash
+uip rpa build "<PROJECT_DIR>" --log-level Warn --output json
+```
+
+`validate` is static analysis and misses compile-time failures: unknown member names, invalid enum values, member resolution / CacheMetadata failures, and JIT failures like `JIT compilation is disabled for non-Legacy projects` — see [xaml/csharp-activity-binding-guide.md § C# Expression Pitfalls](xaml/csharp-activity-binding-guide.md#c-expression-pitfalls). If `build` fails, apply the Phase 2 fix loop (fix one root cause, re-run, cap at 5 attempts). A successful `run` smoke test substitutes for `build` — `run` compiles internally. Prefer the `run --skip-build` form when `build` has just passed (see Smoke Test below).
+
+### Errors `build` catches that `validate` misses
+
+| Error class | Example | Why `validate` misses it |
+|-------------|---------|----------------------------|
+| Unknown member name | `<uix:NGetText Value="[x]" />` (correct: `TextString`) | `validate` does not resolve property names against activity assemblies |
+| Invalid enum value | `Operator="StartsWith"` on `VerifyExpressionWithOperator` (enum has no such member) | Enum membership is checked at CacheMetadata / compile time, not static parse |
+| CacheMetadata / member resolution | Required-extension misses, type-mismatch on `InArgument<T>` | Surfaces only when the runtime instantiates the activity |
+| Attribute-form C# expressions | `Value="x + y"` in `expressionLanguage: CSharp` projects | JIT compiler needs the expression in element form — see [xaml/csharp-activity-binding-guide.md § C# Expression Pitfalls](xaml/csharp-activity-binding-guide.md#c-expression-pitfalls) |
+
+When you see "no diagnostics found" from `validate`, you have not validated the file. Run `build` next.
+
+## Smoke Test
+
+`validate` (static analysis) and `run` (runtime compilation) use different validation paths. Some errors -- such as invalid enum values on activity properties -- pass static validation but fail at runtime. Always treat the smoke test as a critical validation step, not just an optional extra.
+
+After reaching 0 validation errors AND a clean project-level build (Phase 2), run the workflow to catch runtime errors (wrong credentials, missing files, logic bugs) that static validation cannot detect. Use `--skip-build` because the project has just been built clean — default `run` re-validates and re-builds internally, repeating ~10s of compilation:
+
+```bash
+# Run with default arguments (post-build, skip the redundant rebuild):
+uip rpa run --file-path "<FILE>" --skip-build --output json
+# Run with input arguments (repeat --input-arguments per key; = string, := raw JSON):
+uip rpa run --file-path "<FILE>" --skip-build --input-arguments key=value --output json
+# Run with verbose logging for debugging:
+uip rpa run --file-path "<FILE>" --skip-build --log-level Verbose --output json
+```
+
+Use bare `run` (without `--skip-build`) whenever the build artifact may be stale: **(a)** no recent project-level `build` has been performed, OR **(b)** any file has been edited between the last successful `build` and this `run`. `--skip-build` executes the existing compiled artifact, so any post-build edit is silently ignored until a fresh `build` runs.
+
+**When to run:**
+1. Workflow has no compilation errors but you want to verify runtime behavior
+2. Workflow involves file I/O, API calls, or data transformations that could fail at runtime
+3. User specifically asks to test the workflow
+
+**When NOT to run:**
+1. Workflow has side effects (sends emails, modifies databases, calls external APIs) -- warn the user first
+2. Workflow requires interactive input (UI automation, attended triggers)
+3. Compilation errors still exist (fix those first)
+
+**If runtime errors occur:** Analyze the output, apply the fix-one-thing rule, and loop back to fix. Stop after 2 failed runtime retry attempts and present the user with error details, a suggested fix, and options:
+
+```
+Workflow execution failed after 2 retry attempts.
+
+**Error Details:** <specific error message and location>
+**Suggested Fix:** <analysis of what went wrong>
+**Next Steps:** Would you like me to:
+A) <recommended fix approach>
+B) <alternative approach>
+C) <user-driven approach>
+```
+
+---
+
+## RPA-Specific Fix Procedures
+
+### Resolving Dynamic Activity Custom Types
+
+Dynamic activities (e.g., Integration Service connectors) retrieved via `uip rpa activities get-default-xaml` (with `--activity-type-id`) may use **JIT-compiled custom types** for their input/output properties. After the activity is added to the workflow, when you need to discover the property names and CLR types of these custom entities (e.g., to populate an `Assign` activity targeting a custom type property, or to create a variable of a custom type), read the JIT custom types schema:
+
+```
+Read: file_path="{projectRoot}/.project/JitCustomTypesSchema.json"
+```
+
+### Focus Activity for Debugging
+
+When `validate` returns an error referencing a specific activity (by IdRef or DisplayName), use `focus-activity` to highlight it in the Studio Desktop designer. This helps the user see the problematic activity in context and verify fixes visually.
+
+> **Studio Desktop required.** `focus-activity` does not run against headless Studio — it manipulates the Studio Desktop designer UI. Before invoking it, ensure Studio Desktop is up via `uip rpa studio start --project-dir "<PROJECT_DIR>"` (see [environment-setup.md § Edge case: requiring Studio Desktop](environment-setup.md#edge-case-requiring-studio-desktop)). Skip this step entirely on headless-only setups — `validate` already includes the IdRef and file:line in its output, which is enough to locate the activity.
+
+```bash
+# Focus a specific activity by its IdRef (from the error output):
+uip rpa focus-activity --activity-id "Assign_1"
+# Focus all activities sequentially (useful for walkthrough):
+uip rpa focus-activity
+```
+
+This is especially useful when:
+- An error references an activity and you want the user to confirm the context
+- You've made a fix and want to show the user which activity was modified
+- The error is ambiguous and you need to verify which activity instance is affected
+
+---
+
+## Pack & Publish to Orchestrator
+
+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 the `uipath-solution` skill.
+
+### Pick a path
+
+| Goal | Path | Reference |
+|---|---|---|
+| Run the project as an Orchestrator process / link as a Test Manager automation | **Pack → Orchestrator package upload** | This section § Pack → Upload |
+| Edit / visualize in Studio Web | **Solution upload** | the `uipath-solution` skill (solution upload) |
+| Deploy a packed solution (`.uipx`) to Orchestrator with the deployment lifecycle | **Solution publish** | the `uipath-solution` skill (pack-and-deploy lifecycle) |
+
+This section 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 and be OUTSIDE the project directory tree — `pack` refuses an output path inside the project. Use a sibling directory (e.g. `dist/`). |
+
+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. |
+| `--folder-path <PATH>` / `--folder-key <UUID>` | No | Target a specific folder feed. |
+
+Output JSON includes the package `Id` (the package name Orchestrator stores) and `Version`. Hold on to the `Id` — `uip tm testcases link-automation` takes it as `--package-name`; `uip or processes create` takes it as `--package-key` (with `--package-version` separately).
+
+> **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 --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.), delegate to the `uipath-test` skill (its publish-and-link guide).
+
+### 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. The `uipath-solution` skill owns 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 is positional) if you need a clean failure / pass signal.
+
+---
+
 ## CLI Error Recovery
 
 Diagnose by error category, apply the recovery, retry **once** — do not loop the same failing command.
@@ -254,7 +477,7 @@ Diagnose by error category, apply the recovery, retry **once** — do not loop t
 | `timeout`, `ETIMEDOUT` | Cold Helm NuGet restore (30–90 s) or long operation. | Raise both limits together: shell `timeoutSeconds` toward its documented max, and `uip rpa --timeout <timeoutSeconds − 30> <command>` — the shell timeout must exceed `--timeout` by ≥ 30 s or the shell kills the CLI before it can cancel cleanly. For `validate`, also try `--skip-validation`. |
 | `not authenticated`, `401`, `403` | Auth required for cloud features. | `uip login`, then retry. |
 | `package not found`, `version not available` | Wrong package ID or version. | Verify via `uip rpa activities find`; omit `version` to auto-resolve latest. |
-| `project not found`, `no project open` | Wrong `--project-dir` or project not open. | Verify the path points at the `project.json` folder. |
+| `project not found`, `no project open` | Wrong `--project-dir` or project not open. | Verify the path points at the `project.json` folder; if it persists, `uip rpa project open --project-dir "<PROJECT_DIR>"`. For Desktop-only verbs, check instances with the hidden `uip rpa instances list --output json` and run `uip rpa studio start` if none is up. |
 | `not in the project folder` (in `validate`) | Absolute `--file-path` + separator mismatch. | Pass `--file-path` relative to the project root (see [validate](#validate)). |
 | `Studio is busy`, `operation in progress` | Studio processing a prior request. | Wait a few seconds, retry. |
 | Unrecognized error | Unknown | Re-run with `--verbose` for debug detail, then inform the user. |
@@ -270,7 +493,7 @@ Diagnose by error category, apply the recovery, retry **once** — do not loop t
 | **Explore Object Repository** | `uip rpa object-repository get` for the project's apps/screens/elements as JSON, `uip rpa object-repository get-library` for a referenced library's (see [object-repository](#object-repository)); or `Glob` `**/*` under `{PROJECT_DIR}/.objects/` + `Read` metadata for raw files |
 | **Get JIT type definitions** | `Read` `{PROJECT_DIR}/.project/JitCustomTypesSchema.json` |
 | **Activity docs** | See [Installed package activity documentation](#installed-package-activity-documentation) above |
-| **Inspect a NuGet package's API** | `uip rpa packages inspect` — see [coded/inspect-package-guide.md](coded/inspect-package-guide.md) |
+| **Inspect a NuGet package's API** | `uip rpa packages inspect` — see [coded/codedworkflow-reference.md § Inspect NuGet Package Tool](coded/codedworkflow-reference.md) |
 
 ---