@uipath/skills 1.201.0-preview.621 → 1.202.0-preview.635

package/skills/uipath-test/SKILL.md

@@ -16,6 +16,9 @@ Manage UiPath Test Manager resources (projects, test cases, test sets, execution
 - User wants to **generate a shareable test report** tailored to a QA engineer, developer, or release manager
 - User asks about **test coverage, regression trends, or failure rates**
 - User needs a **go/no-go decision summary** based on recent test executions
+- User wants to **triage a failed run** — which cases failed, which assertion broke, which step it died on
+- User asks whether a failure is a **real regression or a flaky test** (result history over past executions)
+- User needs **failure evidence** — screenshots and logs pulled off the failed cases for a defect
 
 ## Concepts
 ### What is Testmanager?
@@ -230,33 +233,15 @@ Object labels are tag-style metadata applied to Requirement, TestCase, TestSet,
 ## Critical Rules
 
 1. **Always check login first** — run `uip login status --output json` before any Test Manager operation. If not authenticated, run `uip login` to sign in.
-2. **Probe the CLI surface once per session, before the first `uip tm` command.** Run `uip tm testcases --help --output json` (any flags accepted). Result `Success` → post-rename CLI; use the command tables above as-is. `unknown command` / non-zero exit → pre-rename CLI; translate via the [Pre-rename fallbacks](#pre-rename-fallbacks) table before each call. Re-probe on any later `unknown command` error.
-3. **Always pass `--output json`** to every `uip` command — no exceptions. Structured JSON output is what you need to reason about results reliably, even when you only plan to summarize them back to the user.
-4. **Cap retries at 3** for any failing `uip` CLI command. After 3 failures, stop and report the error to the user (see Rule — never fall back to direct REST APIs).
-5. **Handle empty results** — if a list command returns an empty array, stop and inform the user rather than proceeding with a null key. Exception: a zero-result `tm testcases list --filter` call may be a prefix miss rather than a truly empty dataset — apply Rule 9's prefix fallback to disambiguate; stop only when the fallback also finds nothing. Filtered lookups on other resources (project, customfield) returning empty are real empty results — stop as usual.
-6. **Confirm before delete** — always confirm the target resource key with the user before running any `delete` command — unless the user already authorized this exact delete. All delete commands require `--yes` (or `-y`) to proceed; omitting it exits without deleting.
-7. **For operations requiring folder key** — use `uip or folders list -n <folder-name> --all --output json` when the user named a folder; when picking one yourself, list without `--all` so you only get folders you are a member of (run `/uipath-platform` for folder management details).
-8. **Discover before assuming** — never guess automation names, folder keys, project IDs, or test case keys. Always run the matching `list` command first (e.g., `uip tm testcases list-automations`, `uip or folders list -n <folder-name> --all`).
-9. **Narrow `list` calls server-side when the user names an entity.** When the user provides a name, key, label, or tag, check `uip tm <resource> list --help` (or `uip or <resource> list --help`) for the narrowing flag the command exposes and pass it on the `list` call. Never list all results and filter client-side — it wastes tokens and misses paginated entries. Applies to every entity across `uip tm` and `uip or`. Exception: `tm testcases list --filter` matches by prefix. A mid-name term returns zero — retry `--filter` with a broader name prefix from context; re-list without `--filter` only when no workable prefix exists, paging through ALL results (`--limit`/`--offset`) before concluding the target is absent.
-10. **`run` needs a default Orchestrator folder — set one only on the exact missing-folder error.** `uip tm testcases run` and `uip tm testsets run` both require a default folder on the project. Attempt the `run` first and match the failure text exactly: a project with **no** default folder fails with `"Message": "HTTP 400: Please assign folder to project level before executing testcases."` (`errorCode: itemNotFound`). Only on that error, set one with `uip tm project set-default-folder --project-key <PROJECT_KEY> --folder-key <FOLDER_KEY> --output json`, then retry once. Get folder keys with `uip or folders list -n <folder-name> --all --output json`. Do NOT treat other errors as folder problems: an unusable default folder surfaces as an opaque `HTTP 5xx` on the run, and `set-default-folder` with a nonexistent folder key fails with `"HTTP 400: Internal Server Error."` (`errorCode: unknown`) — both stop under Rule 11 rather than triggering a folder overwrite. Never overwrite a default folder that is already working — an arbitrary folder picked off `or folders list` may be one Test Manager rejects, breaking every subsequent run on that project. This recovery is the one named run exception to Rule 11; any other run failure still stops.
-11. **On any `uip` command failure or ambiguity, STOP and ask the user — do NOT fall back to direct REST API calls.** When a `uip` command errors, returns malformed output, or the right flag/value is unclear (e.g., multiple matching entities, missing identifier, unexpected schema), interrupt and ask the user before proceeding. This overrides any instinct to "try the underlying API instead." **Two exceptions, both expected outcomes rather than faults, each identified by its exact error:** (a) a `run` failing with `"HTTP 400: Please assign folder to project level before executing testcases."` — the missing-default-folder signal; set the folder per Rule 10 and retry once. (b) `uip tm wait` exiting with code 2 and `"Timed out after <N>s waiting for execution '<EXECUTION_ID>'. Last status: <status>."` — the bounded `--timeout` working as designed; report the non-finish and carry on with the remaining steps. Other `wait` failures (`Polling failed/interrupted/aborted ...`, exit code 1) are real faults, not timeouts. Every other failure still stops here.
-
-### Pre-rename fallbacks
-
-If the probe in Rule #2 shows singular subjects, the CLI predates the closed-verb-set renames. Translate before running:
-
-| Post-rename (tables above) | Pre-rename equivalent |
-|---|---|
-| `uip tm testcases <verb>` | `uip tm testcase <verb>` |
-| `uip tm testsets <verb>` | `uip tm testset <verb>` |
-| `uip tm executions <verb>` | `uip tm execution <verb>` |
-| `uip tm testcases run` | `uip tm testcase execute` |
-| `uip tm testsets run` | `uip tm testset execute` |
-| `uip tm testcases add --test-set-key … --test-case-keys …` | `uip tm testset add-testcases --test-set-key … --test-case-keys …` |
-| `uip tm testcases remove --test-set-key … --test-case-keys …` | `uip tm testset remove-testcases …` |
-| `uip tm executions testcaselogs list` | `uip tm execution list-testcaselogs` |
-
-`uip tm wait`, `tm testcaselog`, `tm report`, `tm result`, `tm attachment`, `tm project`, `tm user`, `tm requirement` are unchanged on both surfaces.
+2. **Always pass `--output json`** to every `uip` command — no exceptions. Structured JSON output is what you need to reason about results reliably, even when you only plan to summarize them back to the user.
+3. **Cap retries at 3** for any failing `uip` CLI command. After 3 failures, stop and report the error to the user (see Rule — never fall back to direct REST APIs).
+4. **Handle empty results** — if a list command returns an empty array, stop and inform the user rather than proceeding with a null key. Exception: a zero-result `tm testcases list --filter` call may be a prefix miss rather than a truly empty dataset — apply Rule 8's prefix fallback to disambiguate; stop only when the fallback also finds nothing. Filtered lookups on other resources (project, customfield) returning empty are real empty results — stop as usual.
+5. **Confirm before delete** — always confirm the target resource key with the user before running any `delete` command — unless the user already authorized this exact delete. All delete commands require `--yes` (or `-y`) to proceed; omitting it exits without deleting.
+6. **For operations requiring folder key** — use `uip or folders list -n <folder-name> --all --output json` when the user named a folder; when picking one yourself, list without `--all` so you only get folders you are a member of (run `/uipath-platform` for folder management details).
+7. **Discover before assuming** — never guess automation names, folder keys, project IDs, or test case keys. Always run the matching `list` command first (e.g., `uip tm testcases list-automations`, `uip or folders list -n <folder-name> --all`).
+8. **Narrow `list` calls server-side when the user names an entity.** When the user provides a name, key, label, or tag, check `uip tm <resource> list --help` (or `uip or <resource> list --help`) for the narrowing flag the command exposes and pass it on the `list` call. Never list all results and filter client-side — it wastes tokens and misses paginated entries. Applies to every entity across `uip tm` and `uip or`. Exception: `tm testcases list --filter` matches by prefix. A mid-name term returns zero — retry `--filter` with a broader name prefix from context; re-list without `--filter` only when no workable prefix exists, paging through ALL results (`--limit`/`--offset`) before concluding the target is absent.
+9. **`run` needs a default Orchestrator folder — set one only on the exact missing-folder error.** `uip tm testcases run` and `uip tm testsets run` both require a default folder on the project. Attempt the `run` first and match the failure text exactly: a project with **no** default folder fails with `"Message": "HTTP 400: Please assign folder to project level before executing testcases."` (`errorCode: itemNotFound`). Only on that error, set one with `uip tm project set-default-folder --project-key <PROJECT_KEY> --folder-key <FOLDER_KEY> --output json`, then retry once. Get folder keys with `uip or folders list -n <folder-name> --all --output json`. Do NOT treat other errors as folder problems: an unusable default folder surfaces as an opaque `HTTP 5xx` on the run, and `set-default-folder` with a nonexistent folder key fails with `"HTTP 400: Internal Server Error."` (`errorCode: unknown`) — both stop under Rule 10 rather than triggering a folder overwrite. Never overwrite a default folder that is already working — an arbitrary folder picked off `or folders list` may be one Test Manager rejects, breaking every subsequent run on that project. This recovery is the one named run exception to Rule 10; any other run failure still stops.
+10. **On any `uip` command failure or ambiguity, STOP and ask the user — do NOT fall back to direct REST API calls.** When a `uip` command errors, returns malformed output, or the right flag/value is unclear (e.g., multiple matching entities, missing identifier, unexpected schema), interrupt and ask the user before proceeding. This overrides any instinct to "try the underlying API instead." **Two exceptions, both expected outcomes rather than faults, each identified by its exact error:** (a) a `run` failing with `"HTTP 400: Please assign folder to project level before executing testcases."` — the missing-default-folder signal; set the folder per Rule 9 and retry once. (b) `uip tm wait` exiting with code 2 and `"Timed out after <N>s waiting for execution '<EXECUTION_ID>'. Last status: <status>."` — the bounded `--timeout` working as designed; report the non-finish and carry on with the remaining steps. Other `wait` failures (`Polling failed/interrupted/aborted ...`, exit code 1) are real faults, not timeouts. Every other failure still stops here.
 
 ## Quick Start
 
@@ -316,6 +301,7 @@ If the probe in Rule #2 shows singular subjects, the CLI predates the closed-ver
 
 | I want to... | Start here |
 |---|---|
+| **Triage a failed run to a root cause** (failed logs → assertions → step logs → evidence; flaky vs regression) | [references/failure-triage-guide.md](references/failure-triage-guide.md) |
 | **Generate a shareable test report** (tester or release manager view) | [references/test-result-report-guide.md](references/test-result-report-guide.md) |
 | **Publish a project and link it to a Test Manager test case** (Studio/RPA) | [references/publish-and-link-guide.md](references/publish-and-link-guide.md) |
 | **Pack, ingest, and run a Playwright suite on serverless** (pack → upload → labels → run) | [references/playwright-first-mile-guide.md](references/playwright-first-mile-guide.md) |
@@ -324,6 +310,5 @@ If the probe in Rule #2 shows singular subjects, the CLI predates the closed-ver
 ## Anti-patterns
 
 - **Do NOT proceed if authentication fails** — all Test Manager API calls require a valid bearer token. Fail fast rather than surfacing confusing 401 errors later.
-- **Do NOT skip the surface probe** (Critical Rule #2). On a pre-rename CLI, post-rename commands fail with `unknown command`; on a post-rename CLI, pre-rename commands fail the same way. The skill targets the post-rename surface and falls back per the [Pre-rename fallbacks](#pre-rename-fallbacks) table. Picking the wrong shape without probing burns a retry on every call.
 - **Do NOT guess command names — verb-noun composites are required.** The CLI uses explicit verb-noun forms; bare verbs do not exist. Confirm with `uip tm <resource> --help --output json`.
 - **Do NOT `link-automation` Playwright test cases.** Playwright ingestion links them to the package automatically; the manual link step belongs to the Studio/RPA pipeline only.

package/skills/uipath-test/references/failure-triage-guide.md

@@ -0,0 +1,90 @@
+# Failure Triage — from a red run to a root cause
+
+Diagnose workflow for a Test Manager execution that failed. Answers three questions in order: **what failed**, **why it failed**, **is it a real defect or a flaky test**.
+
+All commands take `--output json` (Critical Rule #3). Every `list` below is paginated — `--limit` / `--offset`.
+
+## When to use this
+
+- A test set run came back red and you need the cause, not the count
+- Someone asks "is this test actually broken, or just flaky?"
+- A release decision needs evidence attached, not a summary
+- CI reported a failure and you have only the execution ID
+
+For a persona-tailored written report, use [test-result-report-guide.md](test-result-report-guide.md) instead — that answers "what do I tell stakeholders", this answers "what is wrong".
+
+## The triage ladder
+
+Walk down. Each rung narrows the blast radius; stop at the rung that answers the question.
+
+| Rung | Command | Answers |
+|---|---|---|
+| 1. Execution totals | `uip tm executions get-stats --execution-id <UUID> --project-key <KEY>` | How bad? Pass/fail/skip counts as the run reports them |
+| 2. Failed cases only | `uip tm executions testcaselogs list --execution-id <UUID> --project-key <KEY> --only-failed` | Which test cases failed |
+| 3. Failed assertion | `uip tm testcaselog list-assertions --project-key <KEY> --test-case-log-id <UUID>` | Which assertion inside the case broke |
+| 4. Step detail | `uip tm teststeplog list --project-key <KEY> --test-case-log-id <UUID>` | Which step it broke on |
+| 5. Evidence | `uip tm attachment download --execution-id <UUID> --only-failed --result-path <DIR>` | Screenshots / logs for the failures |
+
+`--only-failed` on rung 2 is the difference between reading 4 rows and reading 400. Use it — do not pull every log and filter client-side (Critical Rule #9).
+
+IDs chain downward: `testcaselogs list` returns the `test-case-log-id` that rungs 3 and 4 need. Do not guess it.
+
+## Real defect, or flaky test?
+
+A single red run cannot tell you. Ask the test case's own history:
+
+```bash
+uip tm testcases list-result-history --project-key <KEY> --test-case-id <UUID> --only-failed --output json
+```
+
+Read the pattern:
+
+| History | Read |
+|---|---|
+| Fails every run since a known date | Real regression — bisect to what changed at that date |
+| Fails intermittently, same assertion | Flaky test — environment, timing, or test data, not product code |
+| Fails intermittently, different assertions | Unstable environment or shared-state contention between tests |
+| First failure ever | Either a new regression or a new flake — one data point is not a pattern; re-run before concluding |
+
+`--only-failed` here narrows to the failures; drop it when you need the pass/fail *ratio* rather than the failure list.
+
+## Narrowing across many executions
+
+`executions list` covers the common case. Reach for `list-filtered` only when you need what `list` cannot express:
+
+```bash
+uip tm executions list-filtered --project-key <KEY> \
+  --status finished --execution-type automated \
+  --labels <Label1> <Label2> --sort-by <expr> --output json
+```
+
+Use it for label filtering, `--updated-by <userId>`, multi-execution lookup via `--test-execution-ids`, or custom ordering. Labels and execution IDs are **space-separated** variadics.
+
+`executions testcaselogs list` additionally accepts `--results <results...>`, `--statuses <statuses...>` and `--duration-period <period>` (e.g. `last7Days`) — prefer these over post-filtering a wide list.
+
+## Evidence capture
+
+```bash
+uip tm attachment download --execution-id <UUID> --only-failed --result-path ./evidence --output json
+```
+
+`--test-case-name <name>` narrows to one case (case-insensitive). `--test-set-key` can stand in for `--project-key` when you only have the set. Attach what you downloaded to the defect rather than describing it.
+
+## Symptom → first command
+
+| Symptom | Start here |
+|---|---|
+| "The nightly run failed" | Rung 1, then rung 2 |
+| "This one test keeps breaking" | `list-result-history --only-failed` |
+| "Which step does it die on?" | Rung 2 → rung 4 |
+| "Prove it to me" | Rung 5 |
+| "Did anyone re-run it?" | `executions list-filtered --updated-by` |
+| "Is the whole suite degrading?" | `executions list-filtered --status finished --sort-by`, compare `get-stats` across runs |
+
+## Anti-patterns
+
+- **Do NOT report a count as a diagnosis.** `get-stats` says how many failed, never why. Descend the ladder.
+- **Do NOT call one red run a regression.** Check `list-result-history` first; a flaky test misreported as a defect burns a developer's day.
+- **Do NOT list every test case log and filter locally.** `--only-failed`, `--results`, `--statuses` and `--duration-period` exist; client-side filtering misses paginated rows entirely.
+- **Do NOT guess a `--test-case-log-id`.** It comes from `testcaselogs list`; a fabricated UUID returns an error the retry cap will burn through (Critical Rule #4).
+- **Do NOT skip evidence on a defect you are filing.** `attachment download --only-failed` is one call.

package/skills/uipath-test/references/playwright-first-mile-guide.md

@@ -75,7 +75,7 @@ Ingestion is asynchronous and automatic. Poll until the auto-created test cases
 uip tm testcases list --project-key <PROJECT_KEY> --output json
 ```
 
-- Poll **unfiltered**. Do NOT pass `--filter <PackageName>` — `--filter` matches a test case's name or key by **prefix** (see SKILL.md Rule 9), and an ingested test case is named `"<suite> > <test title>"`, so a package name never matches: the call stays empty forever and reads as a false "ingestion never happened".
+- Poll **unfiltered**. Do NOT pass `--filter <PackageName>` — `--filter` matches a test case's name or key by **prefix** (see SKILL.md Rule 8), and an ingested test case is named `"<suite> > <test title>"`, so a package name never matches: the call stays empty forever and reads as a false "ingestion never happened".
 - The rows carry `TestCaseKey` (e.g. `SHIP:1`) plus `Id` (the UUID) and `Name` — count `TestCaseKey`, not `Id`, when polling.
 - Ingestion is done when `TestCount` new test cases from Step 1 are present, each named `"<suite> > <test title>"`. A plain `pack` prints only `Package`, `Output` and `TestCount` — if you want the exact expected names up front, run `--dry-run` first or read `testCases.json` inside the `.nupkg`; otherwise match on the count plus that name shape.
 - `TestCount` from Step 1 is one test case per Playwright **test** — it is not multiplied by the number of Playwright projects (2 tests × 2 projects → 2 test cases).
@@ -85,7 +85,7 @@ uip tm testcases list --project-key <PROJECT_KEY> --output json
 
 ## Step 4 — Set the default folder, create a test set, fill it by label
 
-Set the project's default Orchestrator folder FIRST — both the Step 5 probe and the Step 6 run resolve packages through it (Critical Rule #10):
+Set the project's default Orchestrator folder FIRST — both the Step 5 probe and the Step 6 run resolve packages through it (Critical Rule #9):
 
 ```bash
 uip or folders list --output json    # WITHOUT --all: only folders you are a member of

package/skills/uipath-test/references/publish-and-link-guide.md

@@ -17,7 +17,6 @@ uip tm wait              → block until terminal
 ## Prerequisites
 
 - Logged in: `uip login status --output json`. If not, `uip login`.
-- CLI surface probed (see [/uipath:uipath-test § Critical Rules #2](../SKILL.md#critical-rules)). Commands below use the post-rename shape; on a pre-rename CLI, translate via the [Pre-rename fallbacks](../SKILL.md#pre-rename-fallbacks) table (`testcases` → `testcase`, `run` → `execute`, etc.) before each call.
 - Project builds clean: `uip rpa build "<PROJECT_DIR>" --output json` returns `Result: "Success"`.
 - Test case exists in Test Manager: `uip tm testcases list --project-key <PROJECT_KEY> --output json`. Capture the `ObjKey` (e.g. `DEMO:1`) — it is the `--test-case-key` value.
 

package/skills/uipath-test/references/test-result-report-guide.md

@@ -5,7 +5,6 @@ Detailed instructions for generating persona-tailored test reports from UiPath T
 ## Prerequisites
 
 - Authenticated session
-- CLI surface probed (see [/uipath:uipath-test § Critical Rules #2](../SKILL.md#critical-rules)). Commands below use the post-rename shape; translate via the [Pre-rename fallbacks](../SKILL.md#pre-rename-fallbacks) table on a pre-rename CLI.
 - A Test Manager project key
 - A Test Manager test set key
 
@@ -108,4 +107,4 @@ Stop when: the user is satisfied, the response has no more data, or 3 retries ha
 
 - **Do NOT generate a report without asking for the persona** — a release manager receiving raw test logs is noise; a tester receiving only a pass/fail count is missing the detail they need.
 - **Do NOT fabricate test results** — only report data returned by the API. If executions are empty, tell the user there are no results for the selected filters.
-- **Do NOT build `--output-filter` aggregate expressions to compute counts** — a malformed filter aborts the command, and under Critical Rule 11 that stops the whole report for totals you can tally from the test case logs already fetched.
+- **Do NOT build `--output-filter` aggregate expressions to compute counts** — a malformed filter aborts the command, and under Critical Rule 10 that stops the whole report for totals you can tally from the test case logs already fetched.

package/skills/uipath-troubleshoot/references/activity-packages/ui-automation/interpretations/healing-agent-data.md

@@ -225,7 +225,7 @@ When `healing-fixes.json` contains actionable fixes, present the findings to the
 
 1. Match the XAML activity by `ActivityRefId` → `IdRef` attribute (unique within workflow).
 2. Extract the failed selector and the HA-recommended selector (`enhancedTarget` for self-healing; the chosen detection's `EnhancedTargetDto.PartialSelector`/`FuzzyPartialSelector` for recommendation-only) — these are the `before`/`after` values to surface in the diff and hand to the delegate.
-3. On approval, the apply is **delegated to `uipath-rpa`** per the central apply contract (`SKILL.md` §1 invariant 10 / `references/presenting.md` § Interactive resolutions). `uipath-rpa` owns the XAML selector edit (including XML encoding), runtime selector recovery (it decides when and how to drive the package-bundled `uia-improve-selector`), and validation — all in its own context. Do NOT check for or invoke `uia-improve-selector` here, do NOT run any staging / `--mode recover` / write-back CLI yourself, and do NOT edit the XAML yourself. If approval cannot be obtained, no delegate is available, or the delegation fails, present the concrete change (workflow file, activity, recovered selector) as a recommendation for the user to apply in Studio, and stop. A failed delegation is never a reason to edit the workflow yourself.
+3. On approval, the apply is **delegated to `uipath-rpa`** per the central apply contract (`SKILL.md` §1 invariant 10 / `references/presenting.md` § Interactive resolutions). `uipath-rpa` owns the XAML selector edit (including XML encoding), runtime selector recovery (it decides when and how to drive the package-bundled recover-selector flow), and validation — all in its own context. Do NOT attempt selector recovery here, do NOT run any staging or write-back CLI yourself, and do NOT edit the XAML yourself. If approval cannot be obtained, no delegate is available, or the delegation fails, present the concrete change (workflow file, activity, recovered selector) as a recommendation for the user to apply in Studio, and stop. A failed delegation is never a reason to edit the workflow yourself.
 
 ### Applying `dismiss-popup` Fixes
 

package/skills/uipath-troubleshoot/references/presenting.md

@@ -130,7 +130,7 @@ For each interactive action, in order:
 
 3. **Ask via AskUserQuestion** — the exact apply/dismiss question, plus a project-path follow-up if the path is not already known.
 
-4. **On accept: delegate the apply — never edit the artifact yourself.** Spawn a subagent that loads the artifact's owning skill (`.xaml`/`.cs`→`uipath-rpa`, which itself drives package-bundled selector recovery such as `uia-improve-selector`) and hand it the confirmed change: the workflow file, the activity matched by `ActivityRefId`, the before→after value, and `project_dir`. The delegate edits **in place at `project_dir`** (the user's real working copy — do NOT spawn it into a fresh isolated worktree, which forks a throwaway copy the edit never reaches), applies any XML encoding, and validates (`uip rpa validate --file-path "<WORKFLOW_FILE>" --output json`) — you run none of those steps and no write-back CLI. **After the delegate applies, the confirmation message must restate the confirmed root cause and the complete resolution** — it must stand alone as the investigation's summary for a user returning to only that message; never let it read as if the applied edit were the primary or only fix.
+4. **On accept: delegate the apply — never edit the artifact yourself.** Spawn a subagent that loads the artifact's owning skill (`.xaml`/`.cs`→`uipath-rpa`, which itself drives the package-bundled selector-recovery flow) and hand it the confirmed change: the workflow file, the activity matched by `ActivityRefId`, the before→after value, and `project_dir`. The delegate edits **in place at `project_dir`** (the user's real working copy — do NOT spawn it into a fresh isolated worktree, which forks a throwaway copy the edit never reaches), applies any XML encoding, and validates (`uip rpa validate --file-path "<WORKFLOW_FILE>" --output json`) — you run none of those steps and no write-back CLI. **After the delegate applies, the confirmation message must restate the confirmed root cause and the complete resolution** — it must stand alone as the investigation's summary for a user returning to only that message; never let it read as if the applied edit were the primary or only fix.
 
 5. **On decline, non-answer, unavailable `AskUserQuestion`, no usable delegate, or a delegation that fails/errors: do not modify files.** Present the proposed edit as plain text and stop — a missing/failed approval or a failed delegation is never permission to edit the artifact yourself. If a delegation errored or was spawned more than once, verify whether the edit already landed by reading the target file before doing anything else; never self-edit to "finish" or redo a delegate's work.
 

package/skills/uipath-troubleshoot/references/products/maestro/playbooks/folder-not-accessible.md

@@ -13,7 +13,7 @@ What this looks like:
 
 What can cause it:
 - Robot/user account is not assigned to the target folder
-- Folder name contains characters Maestro's folder-path resolver historically chokes on — e.g., commas (`"Autopilot, Agentic, and Gen AI"` triggered `PLT-82739`)
+- Folder name contains characters Maestro's folder-path resolver historically chokes on — e.g., a comma in the folder name (`"Autopilot, Agentic, and Gen AI"`)
 - Folder was renamed or deleted; bindings still reference the old path or key
 - Solution imported across environments where folder keys differ - keys were baked into the solution. This playbook owns the stale-folder-key diagnosis; the same root cause surfaces as `Request to Integration Services failed with status code '404'` - arrive here from [integration-service-404](integration-service-404.md)
 - API call missing or pointing the `X-UIPATH-OrganizationUnitId` header at the wrong folder

package/skills/uipath-troubleshoot/references/products/maestro/playbooks/generic-error-400.md

@@ -16,10 +16,10 @@ What can cause it:
 - Request headers too long (HA setups with mismatched token-signing certs)
 - Invalid `Content-Type` (must be `application/json`)
 - Expired auth token
-- Maestro frontend bug — historically `MST-4535` "actionable messages" feature surfaced as generic 400 when a new app version was available
+- Known defect in the Action App "actionable messages" feature — surfaced as a generic 400 when a new app version was available
 
 What to look for:
-- Whether actionable messages toggle is enabled on the failing app — if yes, this is the known frontend bug
+- Whether actionable messages toggle is enabled on the failing app — if yes, this is the known defect
 - Whether the workflow uses a custom HTTP request task with hand-crafted headers/body
 - Whether the issue is tied to a specific HA tenant
 
@@ -30,12 +30,12 @@ What to look for:
 
 1. Get the incident: `uip maestro <type> instance incidents <instance-id> -f <folder-key> --output json` — capture any HTTP body returned upstream
 2. Pull the activity inputs to see what was actually sent: `uip maestro <type> instance variables <instance-id> -f <folder-key> --output json`
-3. If the failing element is an Action App task with actionable messages enabled, jump straight to the `MST-4535` resolution
+3. If the failing element is an Action App task with actionable messages enabled, jump straight to the actionable-messages resolution below
 4. For HA setups, request platform logs from the Maestro service — generic 400 here often points to token-signing certificate mismatch across nodes
 
 ## Resolution
 
-- **If actionable messages bug (`MST-4535`):** turn OFF the "Enable actionable messages" toggle on the Action App task. Frontend fix is deployed to disable by default — re-publish to pick it up
+- **If the actionable-messages defect:** turn OFF the "Enable actionable messages" toggle on the Action App task. A fix that disables it by default has shipped — re-publish to pick it up
 - **If malformed JSON:** validate the payload structure
 - **If Content-Type:** set `application/json`
 - **If expired token:** rotate the auth token and retry

package/skills/uipath-troubleshoot/references/products/maestro/playbooks/integration-service-400.md

@@ -13,8 +13,8 @@ What this looks like:
 
 What can cause it:
 - Malformed or invalid request body for the connector action
-- Connector update changed expected `Content-Type` (e.g., Outlook moved from `application/json` to `multipart/form-data` for attachments) breaking already-published activities — historical bug `ENGCE-46376`
-- A previously-bound variable was removed but the connector activity still references it, sending an empty string `""` instead of `null` (Office 365 Send Email historical issue, `PLT-77820`)
+- Connector update changed expected `Content-Type` (e.g., Outlook moved from `application/json` to `multipart/form-data` for attachments) breaking already-published activities
+- A previously-bound variable was removed but the connector activity still references it, sending an empty string `""` instead of `null` (historically seen with Office 365 Send Email)
 - Mismatched connector input schema after a connector version bump
 - Bad connection state (token, scopes) — connection should be re-provisioned
 

package/skills/uipath-troubleshoot/references/products/maestro/playbooks/job-operation-timeout.md

@@ -14,7 +14,7 @@ What this looks like:
 What can cause it:
 - A gateway/proxy (Azure Application Gateway, Cloudflare, nginx) times out before Orchestrator returns. Typical with synchronous call mode where the HTTP connection is held until the job completes
 - Many concurrent action-center tasks each spawning a job — resource contention pushes individual call latency past the gateway threshold
-- Serverless/coded RPA timing out at the serverless layer ("automation cancelled because it reached the time limit") — root cause is on the robot side, not Maestro (tracked in past Slack threads as `MST-6379`)
+- Serverless/coded RPA timing out at the serverless layer ("automation cancelled because it reached the time limit") — root cause is on the robot side, not Maestro
 
 What to look for:
 - Whether the underlying child job is actually `Successful` in Orchestrator while Maestro reports timeout — indicates gateway timeout, not runtime failure

package/skills/uipath-troubleshoot/references/products/maestro/playbooks/no-suitable-runtime-machine.md

@@ -15,7 +15,7 @@ Ownership: the underlying fault is Orchestrator folder capacity/configuration; t
 
 What can cause it:
 - Folder has no machine templates with Unattended or NonProduction runtime slots assigned
-- Folder only has Test Runtimes but Maestro defaults to NonProduction runtime type (tracked historically as `MST-6775`)
+- Folder only has Test Runtimes but Maestro defaults to NonProduction runtime type
 - Tenant has no available runtime licenses
 - Machines exist but are all currently busy or disconnected
 

package/version-manifest.json

@@ -1,5 +1,5 @@
 {
   "schemaVersion": 2,
-  "skillsVersion": "1.201.0-preview.621",
-  "targetCli": "^1.201.0"
+  "skillsVersion": "1.202.0-preview.635",
+  "targetCli": "^1.202.0"
 }

package/skills/uipath-maestro-case/scripts/audit_plan.py

@@ -1,231 +0,0 @@
-#!/usr/bin/env python3
-"""Deterministic grammar audit for the compact no-build plan (tasks/tasks.md).
-
-Usage:
-    python3 audit_plan.py <tasks/tasks.md> [--sdd <sdd.md>]
-
-Read-only. Exit 0 = grammar-clean. Exit 1 = numbered findings on stderr;
-repair the plan with Write/Edit and re-run until clean. Enforces the compact
-`tasks/tasks.md` contract (planning.md § Compact no-build T-entry shape): `## T{N}: task "{Task Name}"` headings, one
-`field: value` per line, legal `activation-mode` / `entry-rule` pairs, lanes on
-sequential runs, no registry-derived keys.
-`--sdd` additionally checks every `sla-status-change(...)` reference in the
-SDD for the 2-arg (breach) / 3-arg (at-risk) quoted shape.
-"""
-
-from __future__ import annotations
-
-import re
-import sys
-from pathlib import Path
-
-TASK_FIELDS = [
-    "stage", "type", "activation-mode", "entry-rule", "lane", "required",
-    "run-only-once", "resource-intent", "identity", "rationale",
-]
-# `lane` is only mandatory for sequential runs; checked separately.
-ALWAYS_REQUIRED = [f for f in TASK_FIELDS if f != "lane"]
-
-# Compact form (`## T{N}: task "Name"`) or canonical full-form build title
-# (`## T{N}: Add <type> task "Name" to "Stage"`) — both are addressable.
-TASK_HEADING = re.compile(
-    r'^## T\d+: (?:task "[^"\n]+"|Add [a-z][a-z-]* task "[^"\n]+" to "[^"\n]+")\s*$'
-)
-ANY_T_HEADING = re.compile(r"^## T\d+\s*[:.]", re.M)
-FORBIDDEN_KEYS = ["taskTypeId", "activityTypeId", "connectionId", "registry-resolved", "recipients-resolved"]
-
-# planning.md § Activation-mode audit — the six user-visible task modes plus
-# `parallel-after-predecessor`.
-ACTIVATION_MODES = {
-    "sequential", "parallel", "parallel-after-predecessor",
-    "event-triggered", "adhoc", "fan-in", "conditional-gate",
-}
-# plugins/conditions/task-entry-conditions/planning.md § activation-mode /
-# rule-type table, keyed by rule. Rules outside this map are explicitly
-# authored event/condition rules and pair with any mode that permits them.
-ENTRY_RULE_MODES = {
-    "runs-sequentially": {"sequential", "parallel-after-predecessor"},
-    "current-stage-entered": {"parallel"},
-    "adhoc": {"adhoc"},
-    "selected-tasks-completed": {"fan-in", "conditional-gate"},
-    "wait-for-connector": {"event-triggered"},
-}
-
-
-def field_value(section: str, field: str) -> str | None:
-    match = re.search(rf"(?im)^\s*[-*]?\s*{re.escape(field)}\s*:\s*(.+)$", section)
-    return match.group(1).strip() if match else None
-
-
-def rule_token(value: str | None) -> str | None:
-    """Leading canonical identifier, dropping any `("selector")` and trailing prose."""
-    match = re.match(r"[a-z][a-z0-9-]*", (value or "").strip().strip('`"\' ').casefold())
-    return match.group(0) if match else None
-
-
-def audit(path: Path) -> list[str]:
-    findings: list[str] = []
-    sequential_lanes: dict[str, list[tuple[str, int]]] = {}
-    text = path.read_text(encoding="utf-8")
-
-    headings = list(re.finditer(r"(?m)^## (T\d+)[^\n]*$", text))
-    if not headings:
-        findings.append("no `## T{N}:` entries found — the compact plan uses T-numbered H2 entries")
-        return findings
-
-    for key in FORBIDDEN_KEYS:
-        if key in text:
-            findings.append(f"forbidden key {key!r} — the no-build plan omits registry-derived data")
-
-    for index, heading in enumerate(headings):
-        end = headings[index + 1].start() if index + 1 < len(headings) else len(text)
-        section = text[heading.start():end]
-        head_line = section.splitlines()[0]
-        label = heading.group(1)
-
-        is_task_entry = TASK_HEADING.match(head_line) is not None
-        looks_like_task = (
-            field_value(section, "stage") is not None
-            and field_value(section, "activation-mode") is not None
-        ) or re.search(r"(?i)\btask\b[^\n]*\"", head_line) is not None
-
-        if not is_task_entry and looks_like_task:
-            findings.append(
-                f'{label}: task heading must be `## {label}: task "{{Task Name}}"` or the canonical '
-                f'`## {label}: Add <type> task "{{Task Name}}" to "{{Stage}}"` (got: {head_line!r})'
-            )
-
-        if not (is_task_entry or looks_like_task):
-            continue
-
-        # One `field: value` per line; semicolon-packed lines hide fields.
-        for field in ALWAYS_REQUIRED:
-            if field_value(section, field) is None:
-                hint = ""
-                if re.search(rf"(?i)[;,]\s*{re.escape(field)}\s*:", section):
-                    hint = " (present mid-line — each field goes on its own line)"
-                findings.append(f"{label}: missing `{field}:` line{hint}")
-
-        activation = (field_value(section, "activation-mode") or "").casefold()
-        mode = rule_token(activation)
-        rule = rule_token(field_value(section, "entry-rule"))
-        if mode is not None and mode not in ACTIVATION_MODES:
-            findings.append(
-                f"{label}: `activation-mode: {mode}` is not a task mode; use one of "
-                f"{', '.join(sorted(ACTIVATION_MODES))}"
-            )
-        elif mode is not None and rule in ENTRY_RULE_MODES:
-            allowed = ENTRY_RULE_MODES[rule]
-            if mode not in allowed:
-                findings.append(
-                    f"{label}: `activation-mode: {mode}` cannot carry `entry-rule: {rule}` — "
-                    f"that rule pairs with {' or '.join(sorted(allowed))} "
-                    f"(list position never normalizes an authored rule into another mode)"
-                )
-        lane = field_value(section, "lane")
-        if "sequential" in activation and (lane is None or not re.match(r"^\d+$", lane)):
-            findings.append(f"{label}: sequential task needs an integer `lane:` line")
-        elif "sequential" in activation and lane is not None:
-            stage = (field_value(section, "stage") or "").strip('"` ')
-            sequential_lanes.setdefault(stage, []).append((label, int(lane)))
-
-    # Sequential runs use consecutive single-task lanes: no duplicates, no gaps.
-    for stage, lanes in sequential_lanes.items():
-        numbers = [n for _, n in lanes]
-        if sorted(numbers) != list(range(min(numbers), min(numbers) + len(numbers))):
-            labels = ", ".join(f"{t}=lane {n}" for t, n in lanes)
-            findings.append(
-                f"stage {stage!r}: sequential lanes must be consecutive single-task numbers with no duplicates; got {labels}"
-            )
-
-    findings.extend(sla_shape_findings(text, path.name))
-    return findings
-
-
-def sla_shape_findings(text: str, source: str) -> list[str]:
-    """sla-status-change references need 2 quoted args (breach) or 3 (at-risk).
-
-    Zero-quoted-arg mentions are summary/prose shorthand and are not flagged.
-    """
-    findings: list[str] = []
-    # Every `#### Stage SLA` block declares its title on its own line —
-    # a collapsed `**SLA Type:** … **SLA Title:** …` line hides the title
-    # from line-start tooling and reference resolution.
-    for match in re.finditer(r"(?im)^####\s+Stage SLA\s*$", text):
-        block_end = re.search(r"(?m)^#{1,4}\s", text[match.end():])
-        block = text[match.end(): match.end() + block_end.start()] if block_end else text[match.end():]
-        if not re.search(r"(?im)^\*\*SLA Title:\*\*\s*\S", block):
-            line_no = text[: match.start()].count("\n") + 1
-            findings.append(
-                f"{source}:{line_no}: '#### Stage SLA' block has no line-start '**SLA Title:**' — "
-                "render '**SLA Type:**' and '**SLA Title:**' as two separate lines"
-            )
-    for line_no, line in enumerate(text.splitlines(), 1):
-        for call in re.finditer(r"sla-status-change\s*\(([^)]*)\)", line, re.I):
-            args = re.findall(r"[\"“‘']([^\"”’']+)[\"”’']", call.group(1))
-            if args and len(args) not in (2, 3):
-                findings.append(
-                    f"{source}:{line_no}: sla-status-change reference needs 2 (breach) "
-                    f"or 3 (at-risk) quoted args; got {len(args)}"
-                )
-            if args and args[0].strip().casefold() == "case":
-                findings.append(
-                    f"{source}:{line_no}: sla-status-change target 'Case' — the case-level target is the literal 'root'"
-                )
-    return findings
-
-
-def plan_repeats_sdd_sla_rules(plan: str, sdd: str) -> list[str]:
-    """Every quoted-arg sla-status-change entry declared in the SDD is repeated
-    verbatim in the plan (compact-contract requirement) — target + each title."""
-    findings: list[str] = []
-    declared: list[list[str]] = []
-    for call in re.finditer(r"sla-status-change\s*\(([^)]*)\)", sdd, re.I):
-        args = re.findall(r"[\"“‘']([^\"”’']+)[\"”’']", call.group(1))
-        if args and args not in declared:
-            declared.append(args)
-    if not declared:
-        return findings
-    lowered = plan.casefold()
-    if "sla-status-change" not in lowered:
-        findings.append(
-            "the SDD declares sla-status-change entry rules but the plan carries none — "
-            "each gets its own T-entry with rule-type: sla-status-change, repeating target and titles verbatim"
-        )
-        return findings
-    for args in declared:
-        missing = [a for a in args if a.casefold() not in lowered]
-        if missing:
-            findings.append(
-                f"plan does not repeat the SDD sla-status-change entry {tuple(args)!r} verbatim — missing: {', '.join(missing)}"
-            )
-    return findings
-
-
-def main() -> None:
-    args = list(sys.argv[1:])
-    sdd: Path | None = None
-    if "--sdd" in args:
-        i = args.index("--sdd")
-        sdd = Path(args[i + 1])
-        del args[i:i + 2]
-    if len(args) != 1:
-        sys.exit(__doc__)
-    findings = audit(Path(args[0]))
-    if sdd is not None:
-        sdd_text = sdd.read_text(encoding="utf-8")
-        findings.extend(sla_shape_findings(sdd_text, sdd.name))
-        findings.extend(plan_repeats_sdd_sla_rules(Path(args[0]).read_text(encoding="utf-8"), sdd_text))
-    if findings:
-        shown = findings[:40]
-        print("AUDIT FAIL — repair these, then re-run:", file=sys.stderr)
-        for n, f in enumerate(shown, 1):
-            print(f"  {n}. {f}", file=sys.stderr)
-        if len(findings) > len(shown):
-            print(f"  … and {len(findings) - len(shown)} more", file=sys.stderr)
-        sys.exit(1)
-    print("AUDIT OK: tasks.md grammar is clean")
-
-
-if __name__ == "__main__":
-    main()