@uipath/skills 1.196.0 → 1.197.0

package/skills/uipath-planner/references/platform-availability-guide.md

@@ -0,0 +1,43 @@
+# Platform Availability Guide
+
+Product × delivery-model availability matrix. Consulted by the [Constraint Gate](product-selection-guide.md#constraint-gate) before any product is recommended. The most expensive SDD defect is an architecture the customer's platform cannot run.
+
+> **As of:** 2026-06 · latest Automation Suite = **2.2510** (the 2025.10 LTS line; versioning is `[Major].[YYMM].[Patch]`), current patch **2.2510.2** (2026-04).
+> **Authoritative live source:** [Product and feature availability across delivery options](https://docs.uipath.com/overview/other/latest/overview/product-and-feature-availability-across-delivery-options) — when this file and that page disagree, the page wins.
+
+## Gating Rules
+
+1. **Gate against the customer's column.** `cloud` → everything below marked Cloud-available. `automation-suite` → the AS column **at the customer's version**: customer AS older than a product's "AS since" version → treat as **Not available**. `standalone` → see the Standalone note below. Version ordering across the renamed scheme: `2021.10 < 2022.4 < 2023.4 < 2024.10 < 2.2510 < 2.2510.2` — the `[Major].[YYMM]` scheme (2.2510 = 2025.10) sorts AFTER every `YYYY.MM` version.
+2. **AS version unknown →** gate against the latest AS column, add an `[SME REVIEW]` row for the version in §16 Deployment Environment, and attach a warning to every product whose "AS since" is 2.2510 or newer (the customer may be on an older Suite).
+3. **Install profile matters for the agentic stack.** Maestro and Agents on AS require the **EKS/AKS or OpenShift** profile (not the classic Linux/k3s profile) plus Temporal-as-a-Service and an AI Trust Layer LLM connection. When the SDD includes them on AS, add a profile-prerequisite warning + `[SME REVIEW]` row.
+4. **Verification rule.** Web-search the authoritative page above before finalizing the SDD when ANY of: a needed cell is marked ⚠ Verify; the customer's AS version is unknown; this file's "As of" stamp is more than ~6 months old. A cell is *needed* only when its product remains a candidate after blocking — blocked products require no verification. Record what was verified (or why verification was skipped) in the `Decisions Made` row 1 reason.
+5. **Even an ✅ AS cell can differ from cloud** in feature depth (per UiPath's own matrix page). Limitations called out in the Notes column go into the SDD as constraints, not footnotes.
+6. **"No cloud connectivity" is ambiguous — classify before gating.** (a) The *install* is offline/air-gapped → treat every "unsupported on offline installs" note (DU modern, Integration Service) as **BLOCK**, and exclude SaaS dependencies (e.g., Microsoft 365 mailboxes) from the architecture. (b) Only the UiPath-cloud link is absent but the network has internet egress → **WARN** + `[SME REVIEW]`. When the statement cannot be classified from context, apply (b) and add an `[SME REVIEW]` row naming the stricter reading's consequences.
+
+## Availability Matrix
+
+> **Scope.** Lists products the planner can route to a skill. Document Understanding / IXP route through `uipath-ixp`. Pure platform/analytics features with no planner build path (Insights, AI Center, Task Mining, Autopilot for Everyone, Studio Web) are intentionally omitted — gate those manually if a PDD names them.
+
+| Product | Cloud | Automation Suite | AS notes | Alternative when blocked |
+|---|---|---|---|---|
+| RPA (Studio, Robot, Orchestrator) | ✅ | ✅ since first AS (2021.10) | No serverless/cloud robots on AS — capacity via Automation Suite Robots or provisioned unattended robots | — |
+| Solutions (`.uipx` deploy) | ✅ | ✅ since **2.2510** | Older AS cannot ingest `.uipx` — the planner's terminal artifact degrades to per-package Orchestrator deploys | Per-package publish via Orchestrator (route deploy tasks to `uipath-platform` instead of `uipath-solution`) |
+| Maestro (.flow / BPMN orchestration) | ✅ | ✅ since **2.2510.2** — EKS/AKS + OpenShift profiles only | Requires Temporal-as-a-Service (auto-enabled); Optimize dashboard cloud-only | Orchestrator queues + dispatcher/performer state machine; Action Center approvals for human gates |
+| Agents / Agent Builder | ✅ | ✅ since **2.2510.2** | Requires AI Trust Layer toggle + ≥1 LLM connection (cloud-hosted or self-hosted model); coded agents via Orchestrator 2.2510 | Deterministic RPA + rule-based decisioning; HITL escalation for judgment steps |
+| Coded Apps (TypeScript web apps) | ✅ (some geo limits) | ❌ **Not available** — cloud only | "Automation Suite and Dedicated deployments are not supported at this time" | **None** — no on-prem app equivalent in this toolchain. Flag the app touchpoint as `[SME REVIEW]`; do not substitute a product the planner cannot build. |
+| API Workflows | ✅ | ✅ since **2.2510** | Maestro integration needs 2.2510.2+ | RPA Process invoked via Orchestrator API / queue |
+| Data Service (Data Fabric entities) | ✅ | ✅ since 2022.4 | No retention/TTL policy on file fields on any delivery model — design storage lifecycle (cleanup process) explicitly when storing files | — |
+| Integration Service | ✅ (full catalog) | ✅ full since **2.2510** (2024.10 EKS/AKS-only, patched) | Not supported with FIPS 140-2 or air-gapped installs; connectors are admin-curated per tenant, not the full cloud catalog — confirm the needed connector is installed | Direct HTTP/REST calls from RPA or API Workflows |
+| Action Center | ✅ | ✅ | Agent escalation integration needs 2.2510.2 | — |
+| Document Understanding (classic) | ✅ | ✅ | — | — |
+| Document Understanding (modern projects) | ✅ | ✅ since 2024.10 | Needs GPU allocation; unsupported on OpenShift / offline installs (per 2024.10 docs — ⚠ Verify for newer) | Classic DU; rule-based extraction for fixed-format generated documents |
+| IXP | ✅ | ❌ Not available (⚠ Verify — on-prem delivery announced for late 2026) | — | DU modern/classic on AS; rule-based extraction for generated PDFs |
+| Test Manager | ✅ | ✅ since 2021.10 (full Test Cloud since 2.2510) | — | — |
+
+## Standalone (MSI Orchestrator) Note
+
+Standalone delivery is Orchestrator + Studio/Robot (+ standalone Test Manager) only. **No** Apps, Integration Service, Studio Web, Data Service, API Workflows, Maestro, Agents, Solutions. ⚠ Verify before relying on any product beyond core RPA + Orchestrator. Default architecture: RPA projects + Orchestrator queues/assets/triggers, deployed as individual packages via `uipath-platform`.
+
+## Maintenance
+
+When a cell changes (UiPath ships or removes a product on a delivery model), update the row AND the "As of" stamp. Keep "AS since" versions — they let the gate handle customers on older Suites without a separate historical table.

package/skills/uipath-planner/references/product-selection-guide.md

@@ -16,6 +16,18 @@ This file is the canonical home for **Levels 1, 1.75, 2.5 Part B, and 3**. RPA-s
 | **2.5. Part B — Merge** | Final unified project list with roles, frameworks, queues | All scopes | This file |
 | **3. Capabilities** | HITL, Integration Service, API Workflow as component | All products | This file |
 
+## Constraint Gate
+
+The delivery model (asked or detected at Phase 1 Step 0) and any user-stated product exclusions filter every candidate **before** any level recommends it. Run the gate at Level 1 (before presenting the primary scope), at Level 1.75 Pass A (before composing the option list), and at Level 3 (before flagging a capability add-on).
+
+1. **Look each candidate product up in [platform-availability-guide.md](platform-availability-guide.md)** under the customer's delivery model column.
+2. **Not available → BLOCK.** Remove the product from the recommendation and from Level 1.75 Pass A options. Recommend the matrix's documented alternative instead. Record the block in the `Decisions Made` row 1 and in the Recommended Scope summary (`Blocked by platform:` line). Row 1 is emitted even when nothing is blocked — it then reads `<delivery model>; no products blocked`.
+3. **Partial / uncertain → WARN.** Keep the product but attach an explicit warning line naming what is limited or unverified, and apply the verification rule in [platform-availability-guide.md](platform-availability-guide.md) before finalizing the SDD.
+4. **User exclusions are blocks.** When the user excludes a product ("we don't want Maestro"), treat it exactly like a matrix block for the rest of the session: never re-offer it at any level or revision, record the exclusion and its reason in the Recommended Scope summary.
+5. **Never silently substitute.** A blocked product's alternative changes the architecture — present the substitution and its consequence in the summary, not buried in a section.
+
+> Delivery model `unspecified` (user picked "Not sure") gates nothing — proceed assuming Automation Cloud, and carry an `[SME REVIEW]` row stating the assumption and which recommended products would be affected if the customer is actually on Automation Suite or standalone.
+
 ## Level 1 — Primary Scope Selection
 
 ### Decision table
@@ -32,6 +44,8 @@ Walk through in priority order. **First match wins.** Signals that match *below*
 | 6 | UI automation, data processing, reusable component, or application testing (no other product fits) | **RPA** (sub-type decided at Level 1.5) |
 | 7 | Multiple coordinated projects across products or mixed RPA sub-types (e.g., Flow + API Workflows, or 2 Libraries + 1 Test Automation project) | **Solution** (composition decided at Level 1.75) |
 
+Apply the [Constraint Gate](#constraint-gate) to the matched primary before presenting it — a first-match product that is blocked on the customer's delivery model is replaced by the matrix's alternative, not presented with a caveat.
+
 ### Solution Signals
 
 A Solution is the correct primary when any of the following applies, even if a single product would otherwise match at priority 1-6:
@@ -153,6 +167,8 @@ The goal of Level 1.75 is to produce a concrete list of projects the SDD will co
 
 ### Pass A — Select products to include (multi-select)
 
+**Gate the option list first.** Before composing the questions, drop every product the [Constraint Gate](#constraint-gate) blocks for this delivery model (matrix block or user exclusion) — do not show a blocked product as a selectable option. When a dropped product had matching Level 1 signals, say so in the question preamble with the alternative from the availability matrix. When the matrix lists no alternative (e.g., Coded Apps on Automation Suite — no on-prem equivalent), state that and mark the touchpoint `[SME REVIEW]`; do not substitute a product the planner cannot build.
+
 `AskUserQuestion` has a hard 4-option cap per question. Pass A covers 8 candidate products, so it **must be a single `AskUserQuestion` call containing two question objects**, each with `multiSelect: true` and ≤4 options. The user answers both questions on one screen; both sets of selections return together.
 
 Invoke exactly like this:
@@ -388,6 +404,8 @@ Emit this block as the Phase 1 summary content:
 ```markdown
 ## Recommended Scope
 **Recommendation:** <SINGLE_PRODUCT | SOLUTION(<PRODUCT_1>, <PRODUCT_2>, ...)>
+**Delivery model:** <cloud | automation-suite <version-if-known> | standalone | unspecified — assumed cloud [SME REVIEW]>
+**Blocked by platform:** <PRODUCT → ALTERNATIVE_APPLIED (matrix | user exclusion), ... | none>
 **Reasoning:**
 - <SIGNAL_FROM_PDD> → <PRODUCT_MAPPING>
 - ...
@@ -403,6 +421,8 @@ Emit this block as the Phase 1 summary content:
 **Decomposition signals matched:** <LIST_MATCHED_SIGNALS_PER_RPA_PROCESS_PROJECT_OR_N/A>
 ```
 
+**Durable home.** This block is conversation output at the Phase 1 checkpoint, but the `## Recommended Scope` lines (`Recommendation:`, `Delivery model:`, `Blocked by platform:`) must also survive into the SDD — every template hosts a `## Recommended Scope` section between `## Decisions Made` and `## Action Required`, emitted in BOTH execution modes (Phase 3 Step 2 item 3). Autonomous mode skips the checkpoint presentation, so the SDD copy is the only durable record of the Constraint Gate outcome.
+
 ### Confirmation question
 
 Right after emitting the summary, confirm the scope via `AskUserQuestion` with the numbered-choice format. **The recommended option is always item 1.**

package/skills/uipath-planner/references/sdd-generation-guide.md

@@ -4,23 +4,54 @@ Step-by-step instructions for transforming a PDD into an SDD. Follow the 3-phase
 
 ## Phase 1 — PDD Analysis & Scope Selection
 
-### Step 0: Determine Execution Mode
+### Step 0: Determine Execution Mode & Delivery Model
 
-Before reading the PDD, ask the user how they want the interaction to work. Use `AskUserQuestion` with the numbered-choice format:
+Before reading the PDD, ask **one `AskUserQuestion` call containing two question objects** — execution mode and delivery model. Batching keeps the prompt budget flat: the delivery model gates every product decision (see [Product Selection Guide → Constraint Gate](product-selection-guide.md#constraint-gate)) and asking it later costs a second interruption.
+
+**Delivery-model CLI preflight — run first, best-effort.** Before composing the questions, try to resolve the delivery model from the active CLI session:
+
+```bash
+uip login status --output json
+```
+
+Map `Data.BaseUrl`'s host:
+
+| BaseUrl host | Record | Question 2 |
+|---|---|---|
+| `alpha.uipath.com`, `staging.uipath.com`, `cloud.uipath.com` | **cloud** | skip |
+| any other (custom) host | **automation-suite**, version unknown | skip — apply the AS-version-unknown rule below |
+| `Status` ≠ `Logged in`, call errors, or no `BaseUrl` | nothing | ask (leave as is) |
+
+Precedence: an explicit user-stated delivery model or a PDD signal **wins over** the preflight — never override an explicit statement with the detected value. The preflight is **best-effort and never blocks** (Rule G-8): on any CLI failure, fall back to asking Question 2.
+
+*Question 1 — Execution mode:*
 
 > How should I handle this SDD generation?
 >
 > 1. **Autonomous** *(recommended)* — I will read the PDD, make all decisions, and generate the full SDD. I will only interrupt for hard blockers (PDD unreadable, Agent/Coded App missing critical info, unresolved `[SME REVIEW]` items before finalizing).
 > 2. **Interactive** — I will pause at each phase checkpoint (summary, architecture, final SDD) for your review before proceeding.
 
-Record the choice — it goes into the SDD's `## Planner Handoff` header (Phase 3 Step 2) and propagates to Lane A (task derivation) for task review behavior.
+*Question 2 — Delivery model:*
+
+> Where will this automation run?
+>
+> 1. **UiPath Automation Cloud** — full product catalog available
+> 2. **Automation Suite (self-hosted)** — product availability depends on the Suite version; I will gate recommendations accordingly
+> 3. **Standalone Orchestrator (MSI)** — most restrictive; modern platform products unavailable
+> 4. **Not sure** — I will proceed assuming Automation Cloud and flag the assumption as `[SME REVIEW]`
+
+**Skip Question 2** when the delivery model is already resolved — the user's request states it, the PDD carries a delivery-model signal (see [PDD Analysis Guide → Environment & Constraint Signals](pdd-analysis-guide.md#environment--constraint-signals)), or the CLI preflight above resolved it. Record the resolved value instead of asking. If the answer is Automation Suite and the version is unknown, do not ask a follow-up — gate against the latest matrix column and add an `[SME REVIEW]` row for the version in §16 Deployment Environment.
+
+**Skip Question 1 symmetrically** when the request already states the execution mode ("autonomous", "don't pause for checkpoints", "interactive review"). When both questions are resolved from context, skip the `AskUserQuestion` call entirely and record both values.
+
+Record both choices — they go into the SDD's `## Planner Handoff` header (Phase 3 Step 2) and propagate to Lane A (task derivation): execution mode drives task review behavior; delivery model is passed to specialists as a platform constraint.
 
 In **Autonomous** mode:
-- Skip Phase 1 summary presentation (generate internally, do not wait for confirmation)
+- Skip Phase 1 summary presentation (generate internally, do not wait for confirmation) — the `## Recommended Scope` block still persists into the SDD (Phase 3 Step 2 item 3)
 - Skip Phase 2 architecture review (generate, do not wait)
 - Still ask the SME Review resolution question before writing (Step 1.5) — this is a hard blocker
 - Still ask the Agent/Coded App gap-filling question if triggered — this is a hard blocker
-- **Insert a "Decisions Made" block** at the top of the SDD (immediately after the Planner Handoff header and before any other section) listing the four highest-leverage architectural picks with one-sentence reasons. See Phase 3 Step 2 item 3 for the exact block format. Do **NOT** use `AskUserQuestion` — the picks are decided autonomously; the block makes them scannable in the SDD's first screenful so a reviewer can spot a wrong call without reading the whole document.
+- **Insert a "Decisions Made" block** at the top of the SDD (immediately after the Planner Handoff header and before any other section) listing the five highest-leverage architectural picks with one-sentence reasons. See Phase 3 Step 2 item 3 for the exact block format. Do **NOT** use `AskUserQuestion` — the picks are decided autonomously; the block makes them scannable in the SDD's first screenful so a reviewer can spot a wrong call without reading the whole document.
 
 In **Interactive** mode:
 - Present and wait at every checkpoint as described in the steps below
@@ -56,7 +87,13 @@ These tasks track SDD generation. Implementation tasks are owned by Lane A (task
    - **10-50 pages:** read the ToC first, then read sections in priority order (overview → steps → exceptions → applications → credentials).
    - **Over 50 pages:** read ToC, then read high-priority sections (overview, process steps, exceptions) first, extract as you go, then read remaining sections.
 3. For pasted text over 3000 words, ask the user to paste in sections.
-4. **Docx handling:** if the .docx file renders as raw XML or binary content, tell the user: "The Word document could not be parsed as readable text. Please export it as PDF or paste the content directly." Do not attempt to extract data from garbled output.
+4. **Docx handling:** .docx is a binary format — do NOT Read it directly or attempt to extract data from garbled output. Convert first. Run from the directory where the markdown should land (output defaults to the current working directory):
+
+   ```bash
+   bash <SKILL_DIR>/scripts/docx-extract.sh "<PDD_FILE_PATH>"
+   ```
+
+   `<SKILL_DIR>` is the folder containing this skill's SKILL.md; `<PDD_FILE_PATH>` is the full path to the .docx. The script produces a UTF-8 markdown file plus a `-media/` folder with embedded screenshots — Read both (screenshots feed the canonical-example extraction). Complex multi-paragraph tables may come out as raw HTML `<table>` blocks — parse them, they carry the same data. If the script reports pandoc missing, relay its install command to the user; only if the user cannot install pandoc, fall back to: "Please export the Word document as PDF or paste the content directly." Never drive Word via COM automation.
 5. **Error cases:** if the document cannot be read (corrupt PDF, password-protected, unsupported format), tell the user and ask them to provide it in a different format. If the document does not appear to be a PDD (no process steps, no application details, no exception handling), tell the user and stop.
 6. **Language handling:** if the PDD is not in English, use `AskUserQuestion` with the numbered-choice format:
 
@@ -96,6 +133,8 @@ Skip this step for non-RPA primaries (Agents, Coded Apps, Flow, Case, API Workfl
 
 Run the procedure in [tenant-library-search-guide.md](tenant-library-search-guide.md). Keyword source for step 2: PDD Application Inventory + org-prefix terms (`Common`, `Shared`, `<Company>` if mentioned in the PDD). Output mapping: every selected library → one row in every sub-project's §14 Packages table, and its package ID into §16 Deployment Environment → "Shared libraries referenced". If the auth preflight fails, use the guide's manual fallback and propagate the user's named libraries to §14 / §16 the same way.
 
+**This step is best-effort — it never blocks SDD output.** If the auth preflight errors or auth is unavailable, **Autonomous mode skips library discovery and proceeds with public NuGet only** — do not retry or troubleshoot auth mid-generation, and do not pause. Skip the step entirely if the user's prompt forbids running `uip` commands.
+
 ### Step 3: Detect Gaps
 
 Scan for missing or vague information. Use the Gap Detection Checklist in the [PDD Analysis Guide](pdd-analysis-guide.md) to classify each gap as `[DEFAULT]` or `[SME REVIEW]`.
@@ -106,6 +145,8 @@ Scan for missing or vague information. Use the Gap Detection Checklist in the [P
 
 This step orchestrates four levels of decision. Each level lives in its own canonical reference; this guide does not restate them. Run in order — output of each level feeds the next.
 
+> **Constraint Gate applies at every level.** The delivery model from Step 0 and any user-stated product exclusions filter the candidates before each level recommends — see [Product Selection Guide → Constraint Gate](product-selection-guide.md#constraint-gate) and [platform-availability-guide.md](platform-availability-guide.md).
+
 | Level | Decision | Canonical reference | When |
 |---|---|---|---|
 | **Level 1** | Primary scope (Agents / Coded Apps / API Workflows / Case / Flow / RPA / Solution) | [Product Selection Guide → Level 1](product-selection-guide.md#level-1--primary-scope-selection) | Always |
@@ -263,6 +304,8 @@ Present the architectural core to the user. Wait for approval or adjustments.
 
 > **Progress:** Mark "Generate architecture (Phase 2)" as `completed`. Mark "Generate full SDD (Phase 3)" as `in_progress`.
 
+> **Write early, append incrementally — the file on disk is the deliverable.** Do NOT hold the entire SDD in context and write only at the very end. As soon as Phase 2 has produced the architectural core, write a first valid file: the header + `## Planner Handoff` header **and** the `<!-- planner-handoff:v1 -->` marker + `## Decisions Made` block (autonomous) + the Phase 1 / Phase 2 sections you already have. Then append the remaining Phase 3 sections to that file with follow-up `Edit`/`Write` calls. Rationale: a long autonomous turn can hit the per-turn watchdog mid-generation — an incrementally-written file leaves a gradeable, useful SDD on disk instead of nothing. The Planner Handoff header + marker MUST be in this first write so detection (and grading) works even on a partial file. Step 1.5 (SME resolution) and the Step 2 superset check still run; they patch and verify the already-on-disk file rather than gating the first write.
+
 ### Step 1: Generate Remaining Sections
 
 Fill in all sections of the chosen template not covered in Phase 1 or Phase 2. Section assignments per phase:
@@ -280,7 +323,7 @@ Fill in all sections of the chosen template not covered in Phase 1 or Phase 2. S
 - Value Mappings (RPA)
 - Exception / Error Handling (all)
 - Credentials & Assets (RPA)
-- Deployment Environment (RPA — robot type, Studio/Robot versions, VM hosts, screen resolution, scalability). Fill `[SME REVIEW]` when the PDD does not specify — these fields typically come from the deployment team, not the PDD. Never invent VM names, version pins, or robot types.
+- Deployment Environment (RPA — robot type, Studio/Robot versions, VM hosts, screen resolution, scalability). Fill the Orchestrator row from the Step 0 delivery model (Cloud / Automation Suite + version / standalone); fill `[SME REVIEW]` for the rest when the PDD does not specify — these fields typically come from the deployment team, not the PDD. Never invent VM names, version pins, or robot types.
 - Triggers (Flow)
 - SLA Rules & Escalations (Case)
 - Compliance Constraints (Case)
@@ -319,7 +362,7 @@ This step runs in BOTH Autonomous and Interactive modes — it is a hard blocker
 
 > **Progress:** Mark "Resolve SME review items" as `completed`. Mark "Write SDD to disk" as `in_progress`.
 
-1. Assemble all sections in template order.
+1. Assemble all sections in template order. If you followed the write-early principle above, the file already holds the header + handoff + Phase 1/2 sections — finalize it by appending/patching the remaining sections in template order rather than rewriting from scratch.
 2. **Fill the `## Planner Handoff` header** that appears in every template after `## Document History`. This is the load-bearing detection contract. The Entry Guard accepts **either** the heading OR the adjacent `<!-- planner-handoff:v1 -->` HTML marker as a detection signal — both ship in every template and both should survive into the generated file (so a later session, or a hand-written SDD, still routes to Lane A):
 
    ```markdown
@@ -330,6 +373,7 @@ This step runs in BOTH Autonomous and Interactive modes — it is a hard blocker
    | Field | Value |
    |---|---|
    | **Execution autonomy** | <autonomous | interactive>          ← from Phase 1 Step 0
+   | **Delivery model** | <cloud | automation-suite | standalone | unspecified> ← from Phase 1 Step 0 (append the Suite version when known, e.g. `automation-suite 2025.1`)
    | **SDD scope** | <single-product | solution>                  ← from Phase 1 Step 4 (Level 1 / Level 1.75)
    | **Project list section** | §11 / §10 + §11 / Project Inventory ← template-specific (RPA single: §11; RPA Master: §10 + §11; Flow: §3 + §7; etc.)
    | **Tasks file** | `<PROCESS_NAME_KEBAB>-tasks.md`             ← planner writes here on first run
@@ -339,31 +383,35 @@ This step runs in BOTH Autonomous and Interactive modes — it is a hard blocker
 
    Do NOT rename the heading or strip the marker. They are redundant on purpose — keeping both means a hand-edit of one signal does not silently break Lane A detection.
 
-3. **Autonomous-mode Decisions Made block.** If `Execution autonomy: autonomous`, insert a `## Decisions Made` block immediately after the Planner Handoff header and before any `Action Required — SME Review Items` block or the Table of Contents. The block makes the four highest-leverage architectural picks scannable in the SDD's first screenful so a reviewer can spot a wrong call without reading the whole document. In `Execution autonomy: interactive`, this block is optional — the user already reviewed each decision at the Phase 1/Phase 2 checkpoints. Skip the block for interactive runs.
+3. **Autonomous-mode Decisions Made block.** If `Execution autonomy: autonomous`, insert a `## Decisions Made` block immediately after the Planner Handoff header and before any `Action Required — SME Review Items` block or the Table of Contents. The block makes the five highest-leverage architectural picks scannable in the SDD's first screenful so a reviewer can spot a wrong call without reading the whole document. In `Execution autonomy: interactive`, this block is optional — the user already reviewed each decision at the Phase 1/Phase 2 checkpoints. Skip the block for interactive runs.
 
    Format:
 
    ```markdown
    ## Decisions Made
 
-   > Autonomous mode picked the four architectural decisions below without a user checkpoint. Override by rerunning in Interactive mode (`Execution autonomy: interactive` in the Planner Handoff header above) or by editing the relevant SDD section.
+   > Autonomous mode picked the five architectural decisions below without a user checkpoint. Override by rerunning in Interactive mode (`Execution autonomy: interactive` in the Planner Handoff header above) or by editing the relevant SDD section.
 
    | # | Decision | Picked | One-sentence reason |
    |---|---|---|---|
-   | 1 | **Scope** (Level 1) | <SINGLE_PRODUCT_OR_SOLUTION_COMPOSITION> | <REASON_TIED_TO_PDD_SIGNAL> |
-   | 2 | **RPA sub-type** (Level 1.5) — per RPA project | <PROCESS_OR_LIBRARY_OR_TEST_AUTOMATION> | <REASON_TIED_TO_PDD_SIGNAL> |
-   | 3 | **Authoring mode** (Level 2) — per RPA project | <XAML_OR_CODED_OR_HYBRID> | <REASON_TIED_TO_PROCESS_BODY_SHAPE> |
-   | 4 | **Framework** — per RPA Process project | <REFRAMEWORK_OR_SEQUENCE> | <REASON_TIED_TO_PER_ITEM_INDEPENDENCE> |
+   | 1 | **Platform constraints** (Constraint Gate) | <DELIVERY_MODEL; BLOCKED_PRODUCTS_WITH_ALTERNATIVES_OR_NONE> | <SOURCE_OF_DELIVERY_MODEL_AND_MATRIX_RULE_APPLIED> |
+   | 2 | **Scope** (Level 1) | <SINGLE_PRODUCT_OR_SOLUTION_COMPOSITION> | <REASON_TIED_TO_PDD_SIGNAL> |
+   | 3 | **RPA sub-type** (Level 1.5) — per RPA project | <PROCESS_OR_LIBRARY_OR_TEST_AUTOMATION> | <REASON_TIED_TO_PDD_SIGNAL> |
+   | 4 | **Authoring mode** (Level 2) — per RPA project | <XAML_OR_CODED_OR_HYBRID> | <REASON_TIED_TO_PROCESS_BODY_SHAPE> |
+   | 5 | **Framework** — per RPA Process project | <REFRAMEWORK_OR_SEQUENCE> | <REASON_TIED_TO_PER_ITEM_INDEPENDENCE> |
    ```
 
    Rules for the block:
    - Each "Picked" cell is a single concrete value, not a placeholder.
    - Each "One-sentence reason" is ≤ 20 words and cites the PDD signal or process characteristic that drove the pick.
-   - For Solution scope, rows 2-4 repeat per RPA project (use a sub-table or one row per project — keep concise).
-   - For non-RPA scopes (e.g., Single-product Agent), rows 2-4 collapse to N/A with one row covering the product-specific Level-1.5-equivalent (framework choice, app type, etc.).
+   - Row 1 always appears, even when nothing was blocked (`cloud; no products blocked`) — the reviewer must see which platform the architecture assumes.
+   - For Solution scope, rows 3-5 repeat per RPA project (use a sub-table or one row per project — keep concise).
+   - For non-RPA scopes (e.g., Single-product Agent), rows 3-5 collapse to N/A with one row covering the product-specific Level-1.5-equivalent (framework choice, app type, etc.).
    - The block does NOT replace the per-section detail later in the SDD — §10 / §11 / §13 still carry the full justification. The block is the **scannable index** of those decisions.
 
-4. If any `[SME REVIEW]` items remain, add a consolidated warning section after the Planner Handoff header (and after the `## Decisions Made` block if present) and before the Table of Contents:
+   In BOTH modes, also emit the `## Recommended Scope` block directly after `## Decisions Made` (directly after the Planner Handoff header when that block is absent — interactive runs): copy the Phase 1 summary's `Recommendation:`, `Delivery model:`, and `Blocked by platform:` lines (see [product-selection-guide.md → Summary block](product-selection-guide.md#summary-block)). Autonomous mode skips the Phase 1 presentation, so this copy is the only durable record of the Constraint Gate outcome.
+
+4. If any `[SME REVIEW]` items remain, add a consolidated warning section after the Planner Handoff header (and after the `## Decisions Made` / `## Recommended Scope` blocks if present) and before the Table of Contents:
 
 ```markdown
 ## Action Required — SME Review Items
@@ -414,17 +462,38 @@ This step runs in BOTH Autonomous and Interactive modes — it is a hard blocker
 
 <SME_REVIEW_COUNT> unresolved SME review items (if any — list them).
 
-**Next:** Phase D is complete. Proceed into Lane A (task derivation) with this SDD path — Lane A derives the task list and emits live `TaskCreate` calls.
+**Next:** Phase D is complete and the SDD is on disk. Lane A (task derivation) continues on the next turn with this SDD path — it derives the task list and emits live `TaskCreate` calls.
 ```
 
+### Step 2.5: Word (.docx) Delivery — only when requested
+
+When the user asks for a Word or client-facing deliverable, convert the written SDD — do not author Word content by hand or drive Word via COM.
+
+**Plain `.docx` of the SDD:**
+
+```bash
+bash <SKILL_DIR>/scripts/sdd-to-docx.sh "<SDD_PATH>.md" [--reference-doc "<TEMPLATE>.docx"]
+```
+
+`--reference-doc` applies a customer template's fonts, heading styles, and margins. The section structure stays as the markdown SDD.
+
+**Official client SDD/ASDD (customer's structure):** the markdown SDD is agent-first; the official Word document is the client deliverable in the customer's own section layout. Ask the user for the template path, then follow [asdd-crosswalk-guide.md](asdd-crosswalk-guide.md) to match the markdown SDD into the template's sections and compute the missing pieces. Do not invent the official section structure.
+
+**Diagrams:** keep them as Mermaid and make them readable — clear node labels, one node per step, a logical direction. They convert as code blocks. Rendering them to images and styling the final document are not this skill's job — leave that to the user or their doc tooling.
+
+If the script reports pandoc missing, relay its install command.
+
+Skip this step entirely when the user did not ask for Word output.
+
 ### Step 3: Proceed to Lane A (Task Derivation)
 
 > **Progress:** Mark "Write SDD to disk" as `completed`. All progress tasks are now done.
 
 The SDD is the deliverable of Phase D. **Do not generate an Implementation Plan section inside the SDD. Do not create implementation `TaskCreate` calls during Phase D. Do not start executing.**
 
-Then transition based on the user's intent:
+> **The SDD write is a turn boundary — do not begin Lane A in the same turn as Phase D.** Once the SDD is on disk, the superset check has passed, and the Step 2 item 9 summary is emitted, that is the end of the current turn. Continue into Lane A on the **next** turn. Rationale: Phase D (read PDD + guides, author §1–§18) and Lane A (parse SDD, derive tasks, emit `TaskCreate`) are each heavy; stacking both in one unbroken autonomous turn is what pushes wall-clock past the per-turn watchdog and loses the whole run. Yielding after a durable SDD write keeps each turn bounded and guarantees the SDD is graded before any further work. This is a turn checkpoint, **not** an `AskUserQuestion` — do not prompt the user; simply let the turn end after the summary.
 
-> The SDD is written. **Fall through into Lane A** with `<sdd-path>` to generate the implementation task list. Lane A reads the `## Planner Handoff` header you just wrote, derives tasks, writes `<process-kebab>-tasks.md` alongside the SDD, and emits live tasks routing to specialist skills.
+Then continue based on the user's intent:
 
-If the user's intent implies implementation ("create / build / implement / set up / make"), continue directly into Lane A — see [pdd-driven-lane-guide.md](pdd-driven-lane-guide.md). If the user only asked to "design / architect / generate an SDD", stop here — the SDD is enough.
+- If the user's intent implies implementation ("create / build / implement / set up / make") → on the next turn, continue into Lane A with `<sdd-path>`. Lane A reads the `## Planner Handoff` header you wrote, derives tasks, writes `<process-kebab>-tasks.md` alongside the SDD, and emits live tasks routing to specialist skills — see [pdd-driven-lane-guide.md](pdd-driven-lane-guide.md).
+- If the user only asked to "design / architect / generate an SDD" → stop here; the SDD is enough.

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

@@ -58,7 +58,11 @@ Combine `Title` and `Authors` filters with `||` when the org uses both conventio
 
 ## Procedure
 
-1. **Auth preflight.** Run a benign call once: `uip or libraries list --limit 1 --output json`. If `Result == "Failure"` with an auth-related message, surface it and switch to the manual fallback (below). Do NOT retry silently.
+1. **Auth preflight (never blocks SDD output).** Run a benign call once: `uip or libraries list --limit 1 --output json`. If it errors or returns `Result == "Failure"` with an auth-related message: do NOT retry, and do NOT troubleshoot auth mid-generation. Then branch by mode:
+   - **Autonomous mode** — skip tenant library discovery entirely: proceed with public NuGet only and record the reuse mandate as a forward note in §16 (equivalent to fallback option 1). Do not pause.
+   - **Interactive mode** — surface the failure and switch to the manual fallback (below).
+
+   Also skip this step (autonomous: public NuGet only) when the user's prompt forbids running `uip` commands.
 2. **Extract keywords** from the source (PDD Application Inventory, user prompt, project intent). Cap at 6:
    - Org-prefix terms: `Common`, `Shared`, `Utils`, `Helpers`, `<Company>` if known
    - Capability terms: `Excel`, `SAP`, `ServiceNow`, `Salesforce`, `Email`, `PDF`, `SharePoint`, `Outlook`, `Citrix`, etc. — drawn from the in-scope applications

package/skills/uipath-planner/scripts/docx-extract.sh

@@ -0,0 +1,54 @@
+#!/usr/bin/env bash
+# Extract a .docx document (typically a PDD) to GitHub-flavored Markdown.
+# UTF-8 safe, preserves tables as pipe tables, extracts embedded images
+# (screenshots) to a media folder so the agent can Read them.
+#
+# Usage: docx-extract.sh <input.docx> [output.md]
+#   output.md defaults to <input-basename>.md in the current directory
+#   embedded media lands in <output-basename>-media/
+#
+# Exit codes: 0 success · 1 usage error · 2 pandoc missing · 3 conversion failed
+set -euo pipefail
+
+if [ $# -lt 1 ] || [ "$1" = "--help" ] || [ "$1" = "-h" ]; then
+  echo "Usage: docx-extract.sh <input.docx> [output.md]"
+  echo "Converts a .docx to GitHub-flavored Markdown via pandoc."
+  echo "Embedded images are extracted to <output-basename>-media/."
+  [ $# -lt 1 ] && exit 1 || exit 0
+fi
+
+if ! command -v pandoc >/dev/null 2>&1; then
+  echo "ERROR: pandoc is not installed." >&2
+  echo "Install it, then re-run:" >&2
+  echo "  Windows: winget install JohnMacFarlane.Pandoc" >&2
+  echo "  macOS:   brew install pandoc" >&2
+  echo "  Linux:   sudo apt-get install pandoc" >&2
+  exit 2
+fi
+
+input="$1"
+if [ ! -f "$input" ]; then
+  echo "ERROR: input file not found: $input" >&2
+  exit 1
+fi
+
+base="$(basename "$input")"
+output="${2:-${base%.*}.md}"
+media_dir="${output%.md}-media"
+
+if ! pandoc "$input" -f docx -t gfm --wrap=none --extract-media="$media_dir" -o "$output"; then
+  echo "ERROR: pandoc conversion failed for $input" >&2
+  exit 3
+fi
+
+echo "Markdown: $output"
+if [ -d "$media_dir" ]; then
+  echo "Media:    $media_dir/ ($(find "$media_dir" -type f | wc -l | tr -d ' ') file(s))"
+  unreadable="$(find "$media_dir" -type f \( -iname '*.emf' -o -iname '*.wmf' \) | tr '\n' ' ')"
+  if [ -n "${unreadable% }" ]; then
+    echo "WARNING: EMF/WMF media cannot be rendered by the Read tool: $unreadable" >&2
+    echo "Ask the user for PNG exports of those figures, or mark dependent extractions [SME REVIEW]." >&2
+  fi
+else
+  echo "Media:    none embedded"
+fi

package/skills/uipath-planner/scripts/sdd-to-docx.sh

@@ -0,0 +1,76 @@
+#!/usr/bin/env bash
+# Convert a generated SDD markdown file to a styled Word document.
+# Optionally takes a corporate .docx as a style reference (--reference-doc)
+# so the output picks up the customer's fonts, heading styles, and margins
+# without committing any template binary to this repo.
+#
+# Usage: sdd-to-docx.sh <sdd.md> [output.docx] [--reference-doc <template.docx>]
+#   output.docx defaults to <input-basename>.docx in the current directory
+#
+# Known limitation: mermaid code blocks are NOT rendered — they appear as
+# code in the document. Render them separately (e.g. mermaid-cli) and replace
+# manually if the deliverable needs diagram images.
+#
+# Exit codes: 0 success · 1 usage error · 2 pandoc missing · 3 conversion failed
+set -euo pipefail
+
+if [ $# -lt 1 ] || [ "$1" = "--help" ] || [ "$1" = "-h" ]; then
+  echo "Usage: sdd-to-docx.sh <sdd.md> [output.docx] [--reference-doc <template.docx>]"
+  echo "Converts an SDD markdown file to .docx via pandoc, with table of contents."
+  echo "--reference-doc applies the styles of an existing Word document."
+  [ $# -lt 1 ] && exit 1 || exit 0
+fi
+
+if ! command -v pandoc >/dev/null 2>&1; then
+  echo "ERROR: pandoc is not installed." >&2
+  echo "Install it, then re-run:" >&2
+  echo "  Windows: winget install JohnMacFarlane.Pandoc" >&2
+  echo "  macOS:   brew install pandoc" >&2
+  echo "  Linux:   sudo apt-get install pandoc" >&2
+  exit 2
+fi
+
+input="$1"
+shift
+if [ ! -f "$input" ]; then
+  echo "ERROR: input file not found: $input" >&2
+  exit 1
+fi
+
+base="$(basename "$input")"
+output="${base%.*}.docx"
+reference=""
+
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --reference-doc)
+      [ $# -ge 2 ] || { echo "ERROR: --reference-doc needs a path" >&2; exit 1; }
+      reference="$2"
+      shift 2
+      ;;
+    *)
+      output="$1"
+      shift
+      ;;
+  esac
+done
+
+args=("$input" -f gfm -t docx --toc --toc-depth=2 -o "$output")
+if [ -n "$reference" ]; then
+  if [ ! -f "$reference" ]; then
+    echo "ERROR: reference doc not found: $reference" >&2
+    exit 1
+  fi
+  args+=("--reference-doc=$reference")
+fi
+
+if ! pandoc "${args[@]}"; then
+  echo "ERROR: pandoc conversion failed for $input" >&2
+  exit 3
+fi
+
+echo "Word document: $output"
+if grep -q '```mermaid' "$input"; then
+  echo "NOTE: mermaid diagrams are kept as code blocks, not rendered images." >&2
+  echo "Render and place images separately if the deliverable needs visuals." >&2
+fi