@uipath/skills 1.195.1 → 1.196.0

package/skills/uipath-automation-discovery/SKILL.md

@@ -0,0 +1,234 @@
+---
+name: uipath-automation-discovery
+description: "UiPath automation discovery — mines Slack/email/wikis/CRM/HRIS/ERP for repetitive work, SPOFs, and replicable models; produces a 4-tier prioritized opportunity report with UiPath implementation paths. Use to discover automation opportunities, find what to automate, or run an internal automation audit across an organization. For building a specific automation→uipath-rpa, authoring a Flow→uipath-maestro-flow, working with agents→uipath-agents."
+---
+
+# Automation Discovery
+
+Investigate how employees actually work, then identify and prioritize internal
+automation opportunities backed by real behavioral evidence. Produces a
+UiPath-ready backlog with recommended implementation paths.
+
+## When to Use This Skill
+
+- User asks to **discover automation opportunities** across their organization — before any specific automation project exists
+- User wants to **find manual work to automate** and build a UiPath implementation backlog
+- User asks "what should we automate?" while working with UiPath tools
+- User wants an **internal automation audit** to feed into UiPath Automation Hub or a UiPath pipeline
+- User explicitly invokes `/uipath-automation-discovery`
+
+## Critical Rules
+
+1. **Authorization and privacy first.** Confirm the requester is authorized to analyze the selected systems and employee data. Avoid private channels, DMs, and special-category HR data (payroll, performance reviews) unless explicitly approved. Pseudonymize SPOFs by default (e.g., "Sales Ops Lead A"); use real names only when explicitly authorized. Maintain consistent pseudonyms across the entire report — assign each individual a stable label on first mention and reuse it throughout. Ask about jurisdiction constraints (GDPR, works council, internal policy); apply the stricter rule when uncertain.
+2. **Never assume — always ask first.** Complete the full intake (Phase 0) before mining. You need company context, tool access, org structure, privacy scope, and scope agreement.
+3. **Verify access before mining.** Test each data source with a minimal read-only operation. If access fails, note it and move on — don't block discovery.
+4. **Evidence over opinion.** Every opportunity (Tiers 1-3) must cite a specific source, quantitative metric, and affected role or team. No unsupported claims. If a source yields fewer than 5 signals, mark all findings from that source as low-confidence. Do not promote low-confidence findings above Tier 3, except per Rule 5.
+5. **Replication is always Tier 1.** A proven model backed by a working automation that could replicate elsewhere is the highest-value finding — this overrides Rule 4's Tier 3 cap. If the replicable model's source has fewer than 5 signals, classify as Tier 1 with a low-confidence flag until corroborated by a second source. Always lead with replicable models. Never skip the replicable-model search (Phase 2C).
+
+## Workflow Overview
+
+```
+Phase 0: INTAKE    → Gather context, verify access, agree on scope and privacy
+Phase 1: MINE      → Gather raw data from all verified sources
+Phase 2: ANALYZE   → Extract patterns, SPOFs, replicable models, gaps
+Phase 3: REFLECT   → Layer on business strategy for strategic gaps
+Phase 4: REPORT    → Produce prioritized report with 4 tiers
+Phase 5: HANDOFF   → Map opportunities to UiPath implementation skills
+```
+
+**Stop conditions:** Quick scan caps at 10 findings, Standard at 25, Deep dive
+at 35. Max 2 retries per failed source. Phase 1 timeboxed at 3 hours for deep
+dives. See [references/intake-guide.md](references/intake-guide.md) §0G for details.
+
+## Phase 0: INTAKE (interactive)
+
+Build a complete picture before mining. Ask — don't assume.
+
+See [references/intake-guide.md](references/intake-guide.md) for detailed steps
+covering company context, tool inventory, access verification, org structure,
+output preferences, user hypotheses, scope control, and privacy authorization.
+
+**Key outputs from intake:**
+- Company context and department list
+- Tool & system inventory with verified access
+- Agreed scope (quick scan / standard / deep dive) with finding caps
+- Privacy scope (pseudonymize by default, jurisdiction constraints)
+
+## Phase 1: MINE
+
+Cast a wide net. Prioritize by signal density. Use parallel agents (Agent tool
+with `subagent_type: general-purpose`, one agent per source category).
+
+See [references/mining-guide.md](references/mining-guide.md) for detailed
+per-source guidance on what to look for and how to search.
+
+**Source priority when time is limited:**
+1. Messaging help channels — highest signal, fastest to mine
+2. Email patterns — reveals hidden recurring work
+3. CRM/ERP — reveals structured process bottlenecks
+4. Wiki/docs — reveals existing automation landscape
+5. Issue tracker — reveals service desk patterns
+6. HRIS — reveals people-process friction
+7. Web research — reveals strategic gaps
+
+Note: Web research (priority 7) feeds Phase 3 strategic analysis. Even under
+time pressure, do a brief web search for the company's public financials and
+strategy — this takes minutes and enables Tier 4 findings.
+
+Work with whatever access is verified. Even messaging channels alone can yield
+15+ opportunities. Each additional source adds depth, not changes the methodology.
+
+**Checkpoint:** After Phase 1, share a raw signal summary with the user:
+"I found X help channels, Y existing automation projects, Z departments.
+Want me to go deeper on anything before I analyze?" If the user requests
+deeper mining, run at most 1 additional targeted pass, then proceed.
+
+## Phase 2: ANALYZE
+
+Transform raw data into structured findings.
+
+### 2A. Behavioral Patterns
+
+Per department, answer: What's manual? What questions repeat? What approvals
+stall? What reports are compiled by hand? What data is swivel-chaired between
+systems? What handoffs break? What scheduled tasks are done by humans?
+
+### 2B. Single Points of Failure
+
+Identify roles that are sole responders. If they're out, the process stops.
+Pseudonymize by default — use role/team labels unless naming is authorized.
+
+```
+| Role/Pseudonym | System/Channel | Function | Risk |
+```
+
+These are the highest-urgency targets.
+
+### 2C. Proven Replicable Models
+
+The most important finding. Look for automation already working in one area
+that could replicate to others:
+- Bot in one channel but not others
+- Auto-routing in one team but manual elsewhere
+- Dashboard auto-generated for one dept but compiled by hand for another
+
+```
+| Working Model | Where It's Missing | Addressable Volume |
+```
+
+**Greenfield case:** If no existing automations are found (nothing to replicate),
+Tier 1 will be empty. Promote the highest-volume Tier 2 finding to the headline
+slot and note that the company has no proven models to replicate yet.
+
+### 2D. Department Coverage Map
+
+```
+| Department | Existing Automations | Key Gap |
+```
+
+Flag ZERO-coverage departments as biggest blind spots.
+
+### 2E. Process Deep Reads
+
+For promising existing projects, extract: pain point, manual process today,
+volume/frequency, ROI if documented, systems involved, dev status.
+
+Apply low-confidence handling per Critical Rule 4.
+
+**Checkpoint:** Share analysis summary with user before reflecting:
+"Here are the top patterns, SPOFs, and replicable models. Anything surprise you?
+Anything I should investigate further?" If the user requests deeper analysis,
+run at most 1 additional targeted pass, then proceed to Phase 3.
+
+## Phase 3: REFLECT
+
+Identify gaps behavioral data won't reveal.
+
+### 3A. Business Context
+
+Research via web search, investor docs, or internal strategy pages:
+revenue, growth, strategic priorities, competitive challenges, key metrics.
+
+### 3B. Strategic Gaps
+
+For each of the company's documented strategic priorities, ask: "Is there an
+internal automation that accelerates this?" Only include Tier 4 opportunities
+that map to both a documented strategic priority and an observed Phase 1-2 gap.
+
+Use this table as a starting prompt (covers common enterprise priorities) —
+adapt to the company's actual strategy and do not include rows where no gap
+was observed:
+
+| Priority | Potential Automation |
+|---|---|
+| Revenue growth | Lead scoring, pipeline acceleration, renewal prediction |
+| Cost reduction | Self-service portals, report automation, process standardization |
+| Customer retention | Health scoring, churn prediction, proactive outreach |
+| Market expansion | Localization, compliance automation, partner enablement |
+| Compliance | Audit trails, policy enforcement, automated reporting |
+| Talent retention | Onboarding, engagement monitoring, career pathing |
+
+### 3C. Dogfooding Check (skip unless the company sells automation/AI/productivity tools)
+
+Does the company use its own product internally? Is there a coverage metric?
+What's the narrative gap between what they sell and what they do internally?
+
+## Phase 4: REPORT
+
+Produce a prioritized report in the user's preferred platform.
+See [references/report-template.md](references/report-template.md) for structure,
+tier definitions, evidence standards, and platform-specific guidance.
+
+### Quality Bar
+
+- Every opportunity has specific evidence (source, metric, affected role/team)
+- No unsupported claims (except Tier 4, which references strategy docs)
+- SPOFs identified by role (or name if authorized)
+- Replicable models highlighted as Tier 1
+- Department map is complete (all departments, not just gapped ones)
+- ROI benchmarks from existing projects included
+- Strategic analysis ties to real financials
+
+## Phase 5: HANDOFF
+
+Map each Tier 1-2 opportunity to a UiPath implementation path. Add a
+"Next Step" column to the report's Tier 1-2 tables.
+
+| Opportunity Type | Recommended Skill | Artifact |
+|---|---|---|
+| Desktop/app automation (UI, data entry) | →uipath-rpa | Coded workflow (.cs) or XAML |
+| Multi-step automation or orchestration | →uipath-maestro-flow | Flow (.flow) |
+| Scheduled / triggered automation | →uipath-maestro-flow | Flow with trigger |
+| Agent-based (conversational, reasoning) | →uipath-agents | Coded agent |
+| Approval / human review gate | →uipath-human-in-the-loop | HITL node in Flow |
+| Cross-system integration | →uipath-platform | Integration Service connector |
+
+For complex or multi-component opportunities, hand off to →uipath-planner
+for full solution design.
+
+## Execution Strategy
+
+Parallelize Phases 1-3 (Phase 0 is interactive — do not parallelize intake).
+Max 3 concurrent agents using the Agent tool with `subagent_type: general-purpose`:
+- Phase 1: 3 agents — messaging, wiki/tracker, systems of record
+- Phase 2: department-specific behavioral agents (max 3 concurrent)
+- Multiple process doc reads in parallel
+- Web research concurrent with internal mining
+
+Always share interim findings. Don't disappear for hours. Check in after
+each phase with a brief summary and ask if the user wants to adjust scope.
+
+## Reference Navigation
+
+- [references/intake-guide.md](references/intake-guide.md) — Phase 0 detailed steps (company context, tool inventory, access verification, privacy)
+- [references/mining-guide.md](references/mining-guide.md) — Per-source search guidance (load during Phase 1)
+- [references/report-template.md](references/report-template.md) — Output structure, tier definitions, and evidence standards (load during Phase 4)
+
+## Anti-patterns
+
+- **Mining before intake.** Never start searching systems before completing Phase 0. Without context you'll waste time on irrelevant signals.
+- **Naming individuals without consent.** Always pseudonymize SPOFs unless the requester explicitly authorizes naming.
+- **Fabricating metrics.** If a source returns sparse data, mark findings as low-confidence. Never invent volume numbers.
+- **Promising ROI without source citations.** Every ROI estimate must reference an existing project benchmark or explicit data point.
+- **Skipping the replicable-model search.** The highest-value findings are always proven models that can replicate. Never skip Phase 2C.
+- **Speculating from insufficient evidence.** Below signal threshold → mark low confidence. Insufficient evidence → don't promote to Tier 1-3.

package/skills/uipath-automation-discovery/references/intake-guide.md

@@ -0,0 +1,85 @@
+# Intake Guide (Phase 0)
+
+Detailed intake steps. Load this file during Phase 0.
+
+## 0A. Company Context
+
+Elicit from the user:
+- What does the company do? (industry, size, business model)
+- Relationship with automation today? (dedicated COE? ad-hoc? nothing?)
+- Known pain points? (capture as hypotheses to validate, not conclusions)
+
+## 0B. Tool & System Inventory
+
+Ask explicitly for each category. Build this table:
+
+```
+| Category       | Tool             | Access Method        | Verified? |
+|----------------|------------------|----------------------|-----------|
+| Messaging      |                  | MCP / CLI / browser  |           |
+| Email          |                  | MCP / CLI / API      |           |
+| Wiki           |                  | MCP / API / browser  |           |
+| Issue Tracker  |                  | MCP / API / CLI      |           |
+| CRM            |                  | CLI / API / browser  |           |
+| HRIS           |                  | API / browser        |           |
+| ERP / Finance  |                  | API / browser        |           |
+| Code / DevOps  |                  | CLI / API            |           |
+| Monitoring     |                  | API / browser        |           |
+| Expense/Travel |                  | browser              |           |
+| Procurement    |                  | API / browser        |           |
+| Calendar       |                  | MCP / CLI / API      |           |
+| Doc Storage    |                  | MCP / CLI / API      |           |
+| Internal Search|                  | browser              |           |
+```
+
+## 0C. Access Verification
+
+Test each tool with a minimal read-only operation before committing to mine it.
+If access fails, note it and move on — don't block discovery on one tool.
+
+Example access tests (adapt to your environment):
+- Slack: MCP `slack_read_channel` or `slack_search_public`
+- Confluence: MCP `searchConfluenceUsingCql` with simple CQL
+- Jira: MCP `searchJiraIssuesUsingJql` with simple JQL
+- Salesforce: `sf data query --result-format json` (Salesforce CLI)
+- Gmail/Outlook: whichever mail MCP or CLI the user has configured
+- GitHub: `gh api user --jq .login` (GitHub CLI)
+- If a named tool is unavailable, ask the user which installed tool or connector to use. Do not invent CLI flags.
+
+## 0D. Org Structure & Scope
+
+- Point me to an org chart? (wiki page, HRIS, etc.)
+- Complete department list (including shared services: IT, HR, Finance, Legal, Procurement)
+- Any departments off-limits?
+- Key people to watch? (executives, ops leads)
+
+## 0E. Output & Audience
+
+- Where should the report go? (Confluence, Notion, Google Docs, local file)
+- Who is the audience? (leadership, COE, department heads)
+- Draft or publish directly?
+
+## 0F. User Hypotheses
+
+Capture what the user already suspects as search targets, not conclusions:
+- "I think expense is broken" → search for evidence in Phase 1
+- "Sales forecasting takes too long" → look for signals
+
+## 0G. Scope Control
+
+Agree on depth before starting:
+- **Quick scan** (~1 hour): Messaging channels + wiki only. Cap at 10 findings. Stop after 2 source passes with no new high-confidence findings.
+- **Standard** (~3 hours): All verified sources. Full department map. Cap at 25 findings. Max 2 retries per failed source.
+- **Deep dive** (~6+ hours): Per-department behavioral agents. PDD deep reads. Strategic analysis. Cap at 35 findings. Timebox Phase 1 at 3 hours.
+
+Share interim findings after each phase. Ask before going deeper.
+
+## 0H. Privacy & Authorization
+
+Before mining, confirm:
+- Is the requester authorized to analyze these systems and employee data for this purpose?
+- Are private channels, DMs, or special-category HR data (payroll, performance reviews) in scope? Default: excluded.
+- Should findings name individuals or use pseudonyms (e.g., "Sales Ops Lead A")? Default: pseudonymize.
+- Any jurisdiction constraints? (GDPR, works council, internal privacy policy.) Apply the stricter rule when uncertain.
+
+Document the agreed privacy scope. Revisit if you discover sensitive data during mining.

package/skills/uipath-automation-discovery/references/mining-guide.md

@@ -0,0 +1,156 @@
+# Mining Guide by Source Type
+
+Detailed guidance for what to look for and how to search each data source.
+Load this file during Phase 1 for whichever sources are verified.
+
+## Messaging (Slack, Teams, Google Chat)
+
+The single best source. Help channels are the highest-signal proxy for pain.
+
+**What to look for:**
+- All `#help-*` or `#ask-*` channels — capture message counts
+- Whether a bot already handles queries in each channel
+- Who responds most often (potential SPOF)
+- Top 5 repeated question patterns per channel
+- Alert/notification channels with undifferentiated noise
+- Account/customer channels with manually compiled weekly updates
+
+**Search queries (adapt phrasing per platform):**
+```
+"can someone help"          → where people get stuck
+"manually update"           → manual data entry
+"every week I have to"      → recurring manual work
+"should automate"           → employee-identified opportunities
+"waiting for approval"      → approval bottlenecks
+"does anyone know how to"   → knowledge gaps
+"is this documented"        → documentation gaps
+"how do I"                  → process confusion
+"who handles"               → unclear ownership
+```
+
+**Pro tip:** Search for team-specific channels beyond `#help-*`. Channels like
+`#ops-*`, `#team-*`, `#proj-*` often contain manual coordination patterns.
+
+## Email (Gmail, Outlook)
+
+Reveals patterns invisible in messaging: approval chains, vendor communication,
+scheduled manual work, report distribution.
+
+**What to look for:**
+- Recurring emails (daily/weekly reports sent manually)
+- Approval request threads (forwarded chains = manual routing)
+- Vendor/supplier communication (manual order placement, invoice follow-up)
+- Auto-forwarding rules (workarounds for missing integrations)
+- Calendar invites for recurring "data compilation" or "report review" meetings
+- High-volume distribution lists (newsletters, status updates compiled by hand)
+- "FYI" emails with attachments that should be in a shared system
+
+**Search queries:**
+```
+"please find attached the weekly"  → manual report distribution
+"updated spreadsheet"              → manual data compilation
+"please approve"                   → manual approval routing
+"reminder to submit"               → recurring manual process
+subject:"weekly report"            → scheduled manual work
+subject:"monthly update"           → scheduled manual work
+```
+
+## CRM (Salesforce, HubSpot, Dynamics)
+
+Structured workflow data revealing process bottlenecks.
+
+**What to look for:**
+- Manual data entry (fields humans fill that could be auto-populated)
+- Swivel-chairing (copying data between CRM and other systems)
+- Approval workflows and where they stall
+- Report/dashboard creation frequency (manual vs. automated)
+- Case/ticket routing rules and exceptions
+- Lead assignment and follow-up compliance gaps
+- Quote-to-close cycle time bottlenecks
+- Data hygiene (duplicates, stale records, missing fields)
+- Chatter/activity feed patterns (manual status updates)
+
+**Salesforce-specific queries:**
+```
+sf data query --result-format json "SELECT Id, Subject, Status FROM Case WHERE Status = 'Escalated'"
+sf data query --result-format json "SELECT Id, StageName, LastModifiedDate FROM Opportunity WHERE StageName = 'Closed Won' AND LastModifiedDate = LAST_N_DAYS:30"
+```
+
+## Wiki / Knowledge Base (Confluence, Notion, SharePoint)
+
+**What to look for:**
+- Internal automation spaces ("INTAUTO", "COE", "RPA", "automation")
+- Process documentation per department (PDDs, SOPs, runbooks)
+- Pages mentioning "manual process", "pain point", "bottleneck"
+- Org charts and department structure pages
+- Existing automation pipeline/backlog/idea list
+- Process mining outputs
+- Meeting notes with recurring action items never completed
+
+**Confluence CQL examples:**
+```
+type = page AND text ~ "manual process" ORDER BY lastModified DESC
+type = page AND text ~ "automation" AND space = "{space_key}"
+type = page AND title ~ "runbook" ORDER BY lastModified DESC
+```
+
+## Issue Tracker (Jira, Linear, Asana, ServiceNow)
+
+**What to look for:**
+- Internal ops projects and backlogs
+- Issues tagged "automation", "process improvement", "manual"
+- Service desk request patterns (what employees ask IT/HR/Finance for)
+- Recurring ticket types (same request weekly = automation candidate)
+- SLA breaches and escalation patterns
+- Ticket volume per category over time
+
+**Jira JQL examples:**
+```
+project = {proj} AND labels = "automation" ORDER BY created DESC
+project = {proj} AND type = "Service Request" ORDER BY created DESC
+project = {proj} AND status = "Waiting for Support" AND updated < -7d
+```
+
+## HRIS (Workday, BambooHR, ADP)
+
+**What to look for:**
+- Onboarding/offboarding workflows and manual steps
+- Time-off and leave management friction
+- Performance review process pain points
+- Payroll processing manual interventions
+- Benefits enrollment confusion patterns
+- Name/email change processes that require multi-system updates
+- Headcount reporting manual compilation
+
+## ERP / Finance (SAP, NetSuite, QuickBooks)
+
+**What to look for:**
+- Manual journal entries and reconciliation
+- Invoice processing and approval workflows
+- Purchase order creation and vendor management
+- Month-end/quarter-end close procedures
+- Expense report processing and reimbursement delays
+- Intercompany transactions requiring manual coordination
+- Tax filing and compliance reporting
+- Revenue recognition manual steps
+
+## Code / DevOps (GitHub, GitLab, Azure DevOps)
+
+**What to look for:**
+- CI/CD pipeline manual steps (approvals, environment promotion)
+- Deployment checklists maintained manually
+- Release notes compiled by hand from commit logs
+- On-call rotation management (manual or automated?)
+- Incident postmortem → action item tracking gaps
+- Feature flag management manual steps
+- Dependency update processes
+
+## Monitoring (Datadog, PagerDuty, Rootly)
+
+**What to look for:**
+- Alert channels with undifferentiated noise (high volume, all same severity)
+- P1/critical signals buried in noise
+- Staging and production alerts mixed in same channel
+- Incident response workflows with manual steps
+- Post-incident review processes
+- SLA tracking and breach notification gaps

package/skills/uipath-automation-discovery/references/report-template.md

@@ -0,0 +1,95 @@
+# Report Template
+
+Adapt the output format to whatever the company uses (Confluence, Notion,
+Google Docs, SharePoint, or local markdown). The structure below is universal.
+
+## Page Structure
+
+```
+Title: Internal Automation Discovery Report — {Month} {Year}
+
+1. Header
+   - Author, date, sources summary (list every system mined)
+
+2. Executive Summary
+   - Total opportunities found
+   - #1 insight (the replicable model finding — this is always the headline)
+   - Meta-insight (biggest strategic gap or dogfooding finding)
+
+3. Part 1: Behavioral Analysis
+   3a. Replicable Model Opportunity Table
+       | Working Model | Where It's Missing | Addressable Volume |
+   3b. Single Points of Failure Table
+       | Role/Pseudonym | System/Channel | Function | Risk |
+   3c. Top 15 Behavioral Opportunities (ranked by evidence)
+       | # | Automation | Source & Evidence | Impact |
+       Each row: specific system, quantitative metric, role/pseudonym (use real names only if authorized)
+
+4. Part 2: Department Coverage
+   4a. Departments with ZERO automation coverage (table)
+       | Department | Existing Automations | Key Gap |
+   4b. Departments with coverage but remaining gaps (table)
+   4c. Key existing automation summaries (table with maturity + ROI)
+   4d. Cross-cutting patterns paragraph (common systems, architectures)
+
+5. Part 3: Strategic Analysis
+   - Business context paragraph (revenue, growth, strategy, challenges)
+   - Strategic gaps table
+       | # | Automation | Strategic Driver | Why Missing Matters |
+
+6. Part 4: Prioritized Recommendations
+   - Tier 1: Replicate Proven Models (task checklist)
+   - Tier 2: Behavioral Workflow Automations (task checklist)
+   - Tier 3: Operational Gaps (task checklist)
+   - Tier 4: Business-Critical Strategic (task checklist)
+
+7. Summary Statistics Table
+   | Metric | Value |
+   Include: data points analyzed, existing automations found,
+   departments mapped, SPOFs identified, total opportunities,
+   ROI benchmarks from existing projects
+
+8. Methodology
+   - Every data source used with what was found
+   - Generation date
+   - "Living document — add your own pain points below"
+```
+
+## Task List Format
+
+Use checkboxes so items can be tracked:
+
+```markdown
+## Tier 1: Replicate Proven Models
+
+- [ ] Replicate {model_name} to {target_1} ({volume} volume)
+- [ ] Replicate {model_name} to {target_2} ({volume} volume)
+
+## Tier 2: Behavioral Workflow Automations
+
+- [ ] {automation_name} ({evidence summary})
+```
+
+## Evidence Standards
+
+Every opportunity MUST include at minimum:
+- **Source**: Where the evidence came from (channel name, system, email pattern)
+- **Quantitative metric**: Message count, hours spent, frequency, ticket volume
+- **Who is affected**: Role/pseudonym (for SPOFs) or team/department; use real names only if authorized
+- **Estimated impact**: Deflection %, hours saved, cycle time reduction, or qualitative
+
+Tier 4 (strategic) is the only tier allowed to lack direct behavioral evidence,
+but must reference specific business metrics or strategy documents.
+
+## Adapting to Output Platforms
+
+| Platform | How to Create |
+|---|---|
+| Confluence | Atlassian MCP `createConfluencePage` with markdown contentFormat |
+| Notion | Notion API or MCP to create page |
+| Google Docs | Google Docs MCP or API |
+| SharePoint | SharePoint API or manual upload |
+| Local file | Write markdown to user's filesystem |
+
+When no wiki/doc platform is available, produce a well-formatted local
+markdown file the user can share however they choose.

package/skills/uipath-coded-apps/SKILL.md

@@ -6,8 +6,6 @@ allowed-tools: Bash, Read, Write, Edit, Glob, Grep, AskUserQuestion
 
 # UiPath Coded Apps
 
-> **Preview** — skill is under active development; surface and behavior may change.
-
 Build, debug, and deploy UiPath Coded Web Applications and Coded Action Apps using the `uip codedapp` CLI and `@uipath/uipath-typescript` SDK.
 
 ## When to Use This Skill

package/skills/uipath-data-fabric/SKILL.md

@@ -5,8 +5,6 @@ description: "UiPath Data Fabric entity/record CRUD via `uip df`. Create entitie
 
 # UiPath Data Fabric — Agent Skill
 
-> **Preview** — skill is under active development; surface and behavior may change.
-
 Data Fabric is UiPath's structured data store. Entities are typed schemas;
 records are rows; file fields store binary attachments.
 

package/skills/uipath-feedback/SKILL.md

@@ -70,7 +70,7 @@ From tools list, extract tool `name` and `version` from each row.
 | Skill context | What to capture | Limits |
 |---|---|---|
 | **Flow** | `uip maestro flow validate <file> --output json`, `.flow` file content, directory listing | `.flow`: first 150 lines; directory: max 30 entries |
-| **RPA** (`.cs` or `.xaml`) | `project.json` dependencies, `uip rpa validate --output json --use-studio`, list of workflow files (`.cs` and/or `.xaml`) | File list: max 20 files; `project.json`: dependencies section only; failing workflow: first 150 lines |
+| **RPA** (`.cs` or `.xaml`) | `project.json` dependencies, `uip rpa validate --output json`, list of workflow files (`.cs` and/or `.xaml`) | File list: max 20 files; `project.json`: dependencies section only; failing workflow: first 150 lines |
 | **Agents** | `pyproject.toml`, `bindings.json` (redact connection values), directory listing | `bindings.json`: redact all values; directory: max 30 entries |
 | **Apps** | `package.json` (name, version, dependencies only), `.uipath/` listing | `package.json`: name + version + dependencies only |
 | **Platform** | `uip login status --output json` output only | Strip tokens from output |

package/skills/uipath-governance/SKILL.md

@@ -6,8 +6,6 @@ allowed-tools: Bash, Read, Write, Edit, Grep, Glob
 
 # UiPath Governance
 
-> **Preview** — skill is under active development; surface and behavior may change.
-
 Uber skill for UiPath governance authoring. Two backing CLI surfaces:
 
 | Surface | Governs | CLI |

package/skills/uipath-human-in-the-loop/SKILL.md

@@ -6,8 +6,6 @@ allowed-tools: Bash, Read, Write, Edit, Glob, Grep
 
 # UiPath Human-in-the-Loop Assistant
 
-> **Preview** — skill is under active development; surface and behavior may change.
-
 Recognizes when a business process needs a human decision point, designs the task schema through conversation, and wires the HITL node into the automation — Flow, Maestro, or Agent.
 
 > **Coded agents:** for wiring HITL inside a coded agent, use the `uipath-agents` skill — see `skills/uipath-agents/references/coded/capabilities/human-in-the-loop.md`.
@@ -26,7 +24,7 @@ Recognizes when a business process needs a human decision point, designs the tas
 - User explicitly asks to **add a HITL node**, human review step, or Action Center task
 - User is building any automation where **a human must act before the process can continue**
 
-**Do not use this skill for:** managing, reassigning, escalating, or monitoring existing Action Center tasks at runtime — use the `uipath-tasks` skill for those operations.
+**Do not use this skill for:** managing, reassigning, escalating, or monitoring existing Action Center tasks at runtime — use the `uipath-tasks` skill for those operations. When answering a runtime task management question, provide only administration guidance. Do NOT suggest adding a HITL node, flow, or automation as a follow-up tip or recommendation — even if delays or escalations are mentioned.
 
 See [references/hitl-patterns.md](references/hitl-patterns.md) for the full business pattern recognition guide.
 
@@ -45,6 +43,7 @@ See [references/hitl-patterns.md](references/hitl-patterns.md) for the full busi
 9. **Never report a failed validation as done.** If `uip maestro flow validate` returns errors, diagnose from the JSON output and fix before reporting to the user.
 10. **Output fields are accessed by `field.id`, not `field.variable`.** The runtime result object uses field IDs as keys — `$vars.<nodeId>.output.<fieldId>`. The `variable` property creates a separate workflow-global variable (`$vars.{variable}`) but does NOT change the key used in the output object.
 11. **Input field binding paths use the upstream output key, not the HITL field's own `id`.** These are two different things: the HITL field `id` identifies the form field (always lowercase); the binding path key is the name used in the upstream script's `return` statement (preserves camelCase). If a script returns `{ supplierName: "Acme" }`, the correct binding is `vars.fetchSupplier.output.supplierName` — writing `suppliername` (the field `id`) produces a path that does not exist at runtime. The form field will be blank; `flow validate` will not catch it. Always derive the binding key from the upstream script source, not from the HITL schema you are designing.
+12. **Downstream scripts must access `$vars.<nodeId>.output`.** Any script node that runs after the HITL node must read `$vars.<nodeId>.output` (the result object) — do not rely solely on `$vars.<nodeId>.status`. Concrete example: `const output = $vars.reviewNode1.output; const reason = output.reason;`. This is required even when the primary routing uses `status`.
 
 ---
 

package/skills/uipath-maestro-bpmn/references/author/references/task-recipes/api-workflow.md

@@ -22,7 +22,7 @@ The model may draft:
 CLI or operator must resolve:
 
 - API workflow resource identity, folder binding, and generated package resources.
-- Solution-style `bindings_v2.json` entries for `uip solution resource refresh`.
+- Solution-style `bindings_v2.json` entries for `uip solution resources refresh`.
 - Dynamic request and response schemas.
 - Fire-and-forget versus wait behavior when the product contract exposes that choice.
 

package/skills/uipath-maestro-bpmn/references/operate/references/run.md

@@ -26,7 +26,7 @@ BPMN project, refresh resources, and run debug from the solution directory:
 ```bash
 uip solution init <SolutionName> --output json
 uip solution project import --source <ProjectDir> --solutionFile <SolutionName>/<SolutionName>.uipx --output json
-uip solution resource refresh --solution-folder <SolutionName> --output json
+uip solution resources refresh --solution-folder <SolutionName> --output json
 cd <SolutionName> && uip maestro bpmn debug <ProjectDirName> --output json
 ```