RaduAna-Maria

test(uipath-planner): add Lane A task-derivation + single-project deferral coverage (#1641) * test(uipath-planner): add Lane A task-derivation + single-project deferral coverage Two gaps the existing planner suite missed — every prior planner test exercised Phase D / SDD generation only: 1. Lane A (PDD-driven task derivation), integration. Stages a finished SDD with a `## Planner Handoff` marker into the sandbox; asserts the skill detects the marker, routes to Lane A, and writes `<process>-tasks.md` that routes work to the right specialists (uipath-rpa + uipath-platform), follows the task-row schema, carries the anti-hallucination rule, includes a mandatory testing task, and does NOT re-author the SDD or start building. Caps max_thinking_tokens to keep the derivation turn short. 2. Single-project deferral, smoke. A self-contained Maestro Flow (decision + HTTP + inline HITL nodes) must route to ONE specialist (uipath-maestro-flow), not fan out through the multi-project planner. Guards the SKILL.md "skip for single-project" rule / most-common-mis-trigger boundary. Both validated with `coder-eval plan`. New tasks carry the full required tag set (skill + tier + mode + lifecycle). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * test(uipath-planner): force skill load in Lane A test; soften brittle criteria Run 28023294472 showed the Lane A task scored 3/7 because the planner skill NEVER LOADED — tools used were {Read: 1, Write: 1}, no Skill invocation. The agent produced a good but ad-hoc task list from general reasoning, so it missed the documented plan-and-tasks-format schema (Task T<N>, Identity, Status, Skill prompt + anti-hallucination rule). The prompt only said "derive the task list" with no instruction to load the skill, so the agent took the shortcut. Fixes: - Prompt now explicitly loads uipath-planner and follows its PDD-driven (Lane A) workflow + documented tasks-file format. This is an integration test of Lane A BEHAVIOR; auto-activation on an SDD is a separate (activation) concern. - Removed the max_thinking_tokens cap so the agent can read and apply the format guide faithfully. - Softened two brittle criteria: testing task accepts Testing/test case/ uipath-test; header check references the source SDD + autonomy instead of exact label strings. Deferral smoke test passed (4/4) unchanged. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * fix(uipath-planner): activate Lane A on existing SDDs; restore natural test prompt Run 28023294472 showed the Lane A test's planner skill never loaded — tools used were only {Read, Write}, no Skill invocation. Forcing the load in the prompt would have masked the real gap, so this fixes the cause instead. Root cause: the description triggers on the literal `sdd.md` filename, but the skill's own convention writes `<process-kebab>-sdd.md`, and it frames task derivation as a step that follows authoring rather than a first-class entry for an SDD the user already has. So PDD->SDD activated (pdd_to_sdd passes) but SDD->derive-tasks did not. - SKILL.md description: trigger on PDD / SDD files (`pdd.md`, `*-sdd.md`) and make "derives the task list from an existing SDD" a first-class capability. - Lane A test prompt: reverted the forced skill-load to a natural user request ("I've finished the SDD ... plan the build from it"), so the test exercises real auto-activation rather than a hand-fed skill. Note: the SKILL.md description change trips the activation recall-eval gate. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * test(uipath-planner): stabilize pdd-to-sdd and constraint-gate SDD tasks Both are main-origin SDD-authoring tasks failing in the full planner suite (run 28360253990). Two distinct root causes, fixed to match the e2e sibling that already passes: pdd_to_sdd: the inline-PDD prompt never told the agent to load the skill, so it free-formed a generic REFramework SDD (1/10 template sections, 0/5 Planner Handoff fields -> score 0.588 FAILURE). Add an explicit "load the uipath-planner skill, follow its RPA SDD template exactly" instruction, mirroring constraint_gate / e2e_rpa_sdd. constraint_gate: the single authoring turn was hard-killed at turn_timeout 1800s with NO SDD on disk (ERROR). Raise to 2700s turn / 3600s task -- the budget the e2e sibling proved sufficient. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * test(uipath-planner): add 11 fast/reliable tasks for >95% headroom Takes the live planner suite from 10 -> 21 active tasks so the skill stays >95% pass-rate even if one heavy SDD-authoring task flakes (20/21 = 95.2%). Additions fill genuine coverage gaps found via /test-coverage, weighted to fast, low-flake smokes: - Lane B (non-PDD path, previously 0% covered): activation smoke, two plan-emission integration tests (multi-skill; dispatcher/performer+deploy), and filesystem-detection routing. - Single-project deferral negatives (SKILL.md carve-outs): single RPA, agent, API workflow, coded app, Case, and Flow-over-deployed-processes -- each must route to its specialist, not the planner. - Lane A entry-guard marker detection in isolation. 9 of 11 are <30s routing/activation smokes; the 2 Lane B plan tests are lane_a-class with lean structural criteria. No skill files touched. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

feat(uipath-planner): delivery model gate + platform availability matrix [UV-14878][UV-14867] (#1441) * feat(uipath-planner): constraint-aware Phase D — delivery model gate + platform availability matrix Field feedback (2 SA sessions): the planner defaulted to cloud-modern picks (Maestro, Coded Apps, DU) on Automation Suite engagements; every blocked product survived review only to fail at delivery. - Phase 1 Step 0 now batches a delivery-model question with execution mode (zero extra prompt cost), skipped when the PDD/request states it - New references/platform-availability-guide.md: product x delivery-model matrix seeded from docs.uipath.com research (as of AS 2.2510.2), gating rules, alternatives for blocked products, verify-when-uncertain rule - Constraint Gate in product-selection-guide: blocks unavailable products at Level 1 / 1.75 / 3; user exclusions never re-offered (new anti-pattern 12) - Planner Handoff contract: additive Delivery model field (marker stays v1); Lane A propagates it into every specialist task prompt; Lane B applies the gate on self-hosted signals - PDD analysis: new Environment & Constraint Signals scan (delivery model, exclusions, signing modality, document storage, robot attendance) - Decisions Made block grows to 5 rows (Platform constraints first) - New eval task tests/tasks/uipath-planner/constraint_gate/ (lint OK) Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(uipath-planner): tighten Constraint Gate per validation-run friction findings Two Phase D simulations (Automation Suite 2024.10 persona on a real DU PDD; cloud persona on a classic-RPA PDD) passed end-to-end; these are the documentation-precision fixes they surfaced: - Step 0: symmetric skip rule for the execution-mode question; skip the call entirely when both answers are in context - Availability guide: explicit version ordering across the renamed [Major].[YYMM] scheme; verification rule scoped to surviving candidates; new rule 6 disambiguating air-gapped install vs no-UiPath-cloud-link - Constraint Gate item 2: Decisions Made row 1 always emitted - Critical Rule 11 + RPA template section 18: rewrite the .uipx terminal artefact to per-package uipath-platform publish when Solutions is blocked (AS older than 2.2510) - SKILL.md nav row: matrix lookup optional on cloud Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * feat(uipath-planner): Office document pipeline — docx PDD ingestion + SDD-to-Word scripts (#1442) * feat(uipath-planner): Office document pipeline — docx PDD ingestion + SDD-to-Word scripts Field feedback: .docx PDDs forced PowerShell Word COM workarounds (hangs, mojibake) and Word SDD deliverables required fully manual conversion. - scripts/docx-extract.sh: .docx PDD -> UTF-8 GFM markdown + extracted screenshots (pandoc), wired into Phase D Step 1 in place of the export-as-PDF bail-out; COM automation explicitly forbidden - scripts/sdd-to-docx.sh: SDD markdown -> styled .docx with optional corporate --reference-doc; new Phase D Step 2.5 (on request only); warns that mermaid blocks are not rendered - Both scripts verified end-to-end against real PDD/SDD artifacts (extraction: clean tables + 3 images; conversion: plain + customer-styled) Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(uipath-planner): docx ingestion fixes from AS-persona validation run - Conversion is now unconditional for .docx (binary format — never Read directly, never wait to observe garbling first); output location and placeholder semantics clarified - HTML-table extraction caveat documented (complex multi-paragraph tables) - EMF/WMF media: script warns (verified firing on a real PDD whose only sample-document figure is .emf), guide adds a no-guessing rule (PNG export or [SME REVIEW] naming the file) Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> --------- Co-authored-by: Claude Fable 5 <noreply@anthropic.com> * fix(uipath-planner): close three constraint-gate gaps from 4-scenario subagent validation Four Phase D simulation runs (cloud / AS 2024.10 / AS version-unknown + user exclusion / standalone air-gapped, on real PDDs) passed every new constraint behavior; these fixes close the three high-severity seams they surfaced: - Lane A + multi-skill pattern tables: deploy routing is now constraint-gated — uipath-solution steps become per-package uipath-platform publish when Solutions is blocked, including the hand-written-SDD Lane A entry that never sees Critical Rule 11 - Recommended Scope block (Recommendation / Delivery model / Blocked by platform) added to all 6 SDD templates as an emit-always section, so the Constraint Gate outcome survives autonomous mode's skipped Phase 1 presentation; wired into product-selection-guide and Phase 3 Step 2 - Critical Rule 11 + RPA template §18 gate comment generalized beyond 'AS 2.2510+' to standalone and user-exclusion blocks Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * feat(uipath-planner): auto-detect delivery model from uip login status at Phase D Step 0 Best-effort CLI preflight resolves the delivery model before asking: - alpha/staging/cloud.uipath.com BaseUrl host -> cloud (skip question) - any other custom host -> automation-suite, version unknown (skip; the existing AS-version-unknown rule applies) - not logged in / call fails -> ask Question 2 as before Explicit user/PDD statement still wins over detection; the preflight never blocks SDD generation (Rule G-8). uip login status is already in the install-permissions allowlist, so no new prompt. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(uipath-planner): trim platform-availability matrix to planner-routable products Per PR review: the matrix listed products the planner can never produce a task for. Keep a row only if the planner can route it to a skill, or it is a documented fallback/manual deliverable for one. - Remove Studio Web, Insights, AI Center, Task Mining, Autopilot for Everyone (skill-less, never a deliverable, not a fallback for any kept row). - Keep IXP + Document Understanding (route through uipath-ixp) and UiPath Apps low-code (Coded Apps fallback). - Add a Scope note documenting the inclusion rule. - Trim the Standalone note to drop the removed Insights/AI Center references. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

feat(uipath-planner): attended re-auth pattern + client ASDD; Coded Apps no on-prem equivalent (PILOT-6045/6046) (#1739) * docs(uipath-planner): scope plan for feedback issues PILOT-6044/6045/6046 Adds the analysis + scoped fix plan for three feedback-derived planner issues, and clarifies the frontmatter routing (a PDD/SDD always routes to Phase D, even for a single RPA process). Scope decisions captured in docs/plan/2026-06-29-planner-feedback-issues.md: - PILOT-6046 (attended 2FA / hardware-token handoff): in scope as a design pattern + detection upgrade; build recipe stays in uipath-rpa. - PILOT-6045: low-code Apps design route in scope; diagram rendering kept doc-only (no mmdc dependency); ASDD = user-supplied-skeleton crosswalk only. - PILOT-6044 (estimation accelerator): descoped from planner; re-home to uipath-automation-discovery or a new sizing skill. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * feat(uipath-planner): implement PILOT-6045/6046 residual fixes PILOT-6046 — attended re-authentication / hardware-token handoff: - Add references/attended-reauth-pattern-guide.md (design-altitude pattern, grounded in verified UiPath attended-automation primitives). - pdd-analysis-guide: human-only login (hardware token / smart card / biometric) now emits a §9 Re-auth Handoff subsection routed to uipath-rpa instead of a bare [SME REVIEW]. - rpa-sdd-template: §9 "Interactive Authentication / Re-auth Handoff" subsection + §16 attended prerequisite. - multi-skill-patterns-guide + SKILL.md reference nav updated. PILOT-6045 — residual SDD gaps: - #3 Low-code UiPath Apps: new assets/templates/apps-lowcode-sdd-template.md (build = manual Apps-designer deliverable), Template-Mapping row, wired as the Coded-Apps-blocked alternative, SKILL.md templates entry. - #1 Diagrams: kept doc-only (no mmdc dependency) — sharpened manual-render guidance + privacy caution in sdd-generation-guide and sdd-to-docx.sh; clarified reflow = regenerate. - #2 ASDD: new references/asdd-crosswalk-guide.md (SDD->ASDD section map, user supplies skeleton; no binary committed), linked from Step 2.5. PILOT-6044 (estimation accelerator): descoped — see plan doc. Verified: all relative links resolve; validate-skill-descriptions.sh exit 0; check-skill-status.py OK (22 skills) under utf-8. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * chore(uipath-planner): drop planning doc from PR Keep docs/plan/2026-06-29-planner-feedback-issues.md as local working notes (untracked, consistent with the rest of docs/plan/) — it is not a shipped artifact. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * fix(uipath-planner): scope low-code Apps template to standalone apps The template wrongly listed an Action Center / HITL "Action app" as a manual low-code build. Those touchpoints DO have tooling — redirect them: HITL/approval form -> uipath-human-in-the-loop; agent-escalation surface -> uipath-agents (provisions the App solution-binding); code-first Action app -> uipath-coded-apps. Only a STANDALONE low-code App (page/dashboard) is a manual Apps-designer build. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * refactor(uipath-planner): drop low-code Apps; client-oriented ASDD; agent tone - Low-code UiPath Apps: removed. No CLI/skill builds it, so it is not an on-prem equivalent for Coded Apps. Deleted the template, dropped the matrix row, set Coded Apps "Alternative when blocked" = None (flag [SME REVIEW]), removed the Template-Mapping row and SKILL.md entry. No invented substitutes. - ASDD: the markdown SDD stays agent-first; the ASDD is the client deliverable. asdd-crosswalk-guide is now a procedure — warn the user for the ASDD template path, match SDD sections into it, compute missing pieces. Updated Step 2.5. - Diagrams: keep Mermaid readable (clear labels, one node per step); rendering to images and styling the doc are not this skill's job. Trimmed the script note. - Tone: agent-instruction tone across the new/edited content; removed internal reasoning and rule citations. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * refactor(uipath-planner): keep rpa-sdd-template fillable-only Strip the agent instructions from the §9 Re-auth Handoff subsection — the template now carries only the fillable table plus a one-line conditional marker pointing to references. Emit/omit rule, soft-vs-hard factor, and the route-to-uipath-rpa guidance live in attended-reauth-pattern-guide.md and pdd-analysis-guide.md. Simplified the §16 prerequisite to a plain placeholder. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * fix(uipath-planner): crosswalk covers the real UiPath SDD template sections Analyzed the official SDD Word template (PURPOSE; AUTOMATED PROCESS DETAILS; RUNTIME GUIDE 3.1-3.6 — architecture diagram, Master Project Runtime Details, per-project tables, workflows, packages; OTHER DETAILS 4.1-4.2; GLOSSARY) and rewrote asdd-crosswalk-guide so every section maps from the markdown SDD or is computed/placeholdered. The default crosswalk now matches the standard UiPath SDD template (RPA / Master-Project oriented); the user's file still wins. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * test(uipath-planner): cover attended re-auth + ASDD crosswalk The branch added two new planner behaviors with no test coverage. Add one integration task each, both fixture-staged (a real input file is the strongest skill-activation signal) and guarded by skill_triggered: - attended_reauth: a PDD whose portal login needs a physical hardware token must emit the §9 Interactive Authentication / Re-auth Handoff subsection with a filled contract and mark the robot Attended (PILOT-6046) — not stop at a bare [SME REVIEW]. - asdd_crosswalk: map the agent-first markdown SDD into a customer's client-SDD template sections, carrying markers instead of fabricating (PILOT-6045 #2). Grades assembled markdown, not .docx, to avoid a pandoc sandbox dependency. Not yet run through coder-eval — passing-run claim still owed before merge. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

feat(skills): merge uipath-design into uipath-planner as Phase D (#1380) Partially reverses the #1310 split: PDD->SDD design (uipath-design) is absorbed into uipath-planner so design + task derivation share one entry point. The merged skill routes via an Entry Guard to three paths: - Phase D (Design): PDD or explicit design request -> author SDD -> Lane A - Lane A (PDD-driven): SDD with ## Planner Handoff / planner-handoff:v1 marker -> derive tasks -> live TaskCreate calls - Lane B (Non-PDD): default for document-less multi-project requests Always-on listing cost drops ~185 tokens/session and the full PDD->SDD->tasks pipeline drops ~40% in loaded SKILL.md body, at the price of ~+800 tokens on partial-scope invocations. Hardening applied on top of the merge: - Routing: fixed dangling Pattern 7 ref, renumbered patterns 1-6, aligned flow Orchestrator deploy (.uipx -> uipath-solution, single package -> uipath-platform), Lane B made the default for document-less multi-project requests, qualified the flow-orchestration trigger, fixed the RPA Project-list-section round-trip (S11 / S10+S11), moved Planner Handoff to position 2 in the solution-overview SDD, completed the routable-skill vocabulary (uipath-api-workflow, uipath-mcp-servers). - Restored guardrails lost in the merge: jargon + domain-injection prohibitions, no third UI-targeting option, no C# top-level recommendation, user-specified SDD output path. - Cleaned stale pre-merge residue: rule/step renumbering, dropped v<VERSION> from Generated by, sequential Phase 3 Step 2 numbering, Q5->Q4, text code fences. - Self-containment: removed cross-skill file link from rpa-product-guide and plugin-namespace path from the RPA template. - Tests: re-pointed stale rule/step refs; flagged the planner activation baseline as unmeasured for the merged 91-prompt dataset. Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

feat(hooks): twin .sh/.ps1 session hooks with polyglot dispatch for zero-install cross-platform support (#1929) * fix(hooks): port session hooks from bash to PowerShell for Windows compatibility Session hooks required bash, which is absent on Windows machines without Git Bash — the plugin's primary enterprise environment. Port all four hooks.json-registered scripts (ensure-uip, suggest-permissions, set-session-env, send-telemetry) to PowerShell compatible with both Windows PowerShell 5.1 and pwsh 7+, and register them with shell: powershell (Claude Code resolves pwsh first, falls back to powershell.exe, and always spawns with -ExecutionPolicy Bypass). - send-telemetry: ConvertFrom-Json replaces the string-aware awk pass; same region-scoped extraction contract, same schema v2 key set. - SessionEnd registration is now synchronous (30s timeout): async hooks still running at session teardown are killed after a grace window shorter than PowerShell + `uip track` startup, silently dropping the session-end event (measured on Claude Code 2.1.202). - ensure-uip hooks.json command propagates the script exit code, which otherwise collapses to 1 under the -Command spawn form. - Contract guards run the hooks via pwsh (preinstalled on ubuntu runners). - validate-skill-descriptions.sh stays bash: it is a git pre-commit/CI validator invoked by .githooks/pre-commit and validate-skills.yml, not a session hook. Verified end-to-end: fresh --plugin-dir session made real tool calls and all six event shapes (session-start, tool-use x3, completion, session-end) reached `uip track` with correct fields and a consistent session_id. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * feat(hooks): twin .sh/.ps1 session hooks with polyglot dispatch No shell ships by default on both Windows and macOS, so a single-language hook always leaves one platform needing an install (bash via Git Bash on Windows, or pwsh on macOS/Linux). Keep BOTH implementations as behavioral twins and let one bash/PowerShell polyglot command per hooks.json entry dispatch to the right twin: bash runs the .sh via backtick-comment substitution; PowerShell hides the bash branch in a <# #> block comment and runs the .ps1. No `shell` field — the polyglot relies on Claude Code's default selection (bash where available, PowerShell on Windows without Git Bash). - Twin sync rule recorded in CLAUDE.md, CONTRIBUTING.md, the PR-review hook checklist, and TWIN SCRIPT headers in all eight scripts: any change to one twin requires the equivalent change to the other in the same PR. - Telemetry contract guards now parametrize over both twins (bash + pwsh) so CI enforces the sync rule. - SessionEnd stays synchronous (30s timeout) for both twins: async hooks are killed at teardown before PowerShell + `uip track` can hand off the session-end event. Verified: polyglot dispatch, silence, exit-code propagation, and stdin passthrough in git-bash and Windows PowerShell 5.1; the registered command strings run both real twins correctly; live headless session delivered all five event shapes through the bash branch. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(hooks): make polyglot dispatch zsh-safe via heredoc wrapper zsh parses the whole -c string before executing, so the bare PowerShell branch (`& ...ps1`) was a parse error and the hook never ran. This matters because Codex executes POSIX hooks via `$SHELL -lc` — zsh on default macOS. Wrap the PowerShell branch in a quoted heredoc (: <<'POLYEOF' ... POLYEOF): sh-family shells now parse it as inert data, while PowerShell still sees it inside the <# #> block comment. Verified: git-bash, bash -lc, dash (sh -c, the Claude Code Linux hook shell), zsh -lc, and Windows PowerShell 5.1 — dispatch, silence, exit-code propagation, stdin passthrough — plus a live `codex exec` run on Windows (Codex spawns hooks via PowerShell there; the .ps1 twin ran with the full payload) and a live Claude Code session (bash branch, full event stream). Known limitation: fish as the login shell under Codex cannot parse the command; the hook is skipped, non-fatally. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * feat(hooks)!: remove the ensure-uip SessionStart hook Drop the automatic @uipath/cli + @uipath/rpa-tool installation at session start (both twins and the hooks.json entry). The plugin now expects the uip CLI to already be on PATH; telemetry silently drops events when it is absent, and the remaining hooks never fail the session. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> --------- Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

feat(hooks): emit plugin-usage telemetry to App Insights on PostToolUse (#1440) * feat(hooks): emit plugin-usage telemetry to App Insights on PostToolUse Add a PostToolUse hook that reports UiPath skills-plugin usage to Azure Application Insights. The hook is gated so it only emits for tool calls attributable to this plugin (uipath: skills, `uip`/`rpa-tool` commands, and edits to UiPath artifacts like .flow/.xaml/.uipx/.bpmn/agent.json/caseplan.json) - calls from other plugins or bare Claude Code are dropped. Each event carries low-cardinality, PII-free fields: toolName, skillName, derived uipSubcommand, fileExt, outcome, permissionMode, effortLevel, os, cliVersion and durationMs. The active UiPath environment (alpha/staging/prod) is resolved from `uip login status` BaseUrl and cached for 1h. cwd is hashed into ai.user.id; transcript paths, raw commands, and stdout/stderr never leave the machine. Non-blocking by contract: no-op unless a connection string is configured, POSTs in a detached subshell, and always exits 0. Replaces the throwaway capture-payload.sh diagnostic. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * fix(hooks): don't source telemetry env cache; use per-user owner-only dir Hardens the env-resolution cache against local code execution. Previously the cache lived at a predictable, world-writable path (${TMPDIR:-/tmp}/uipath- telemetry/env.cache) and was loaded via `. "$cache"`. On a shared host another local user could pre-create that file with arbitrary shell, which this hook would then execute in the invoking user's context. - Parse the cache as DATA into whitelisted variables (grep/cut/tr) instead of sourcing it, so tampered contents can never run as shell. Non-numeric _ts is treated as stale. - Move the cache to a per-user, owner-only directory (${XDG_CACHE_HOME:-$HOME/.cache}/uipath-telemetry, chmod 700) so other local users can't write it in the first place. Verified: a cache seeded with `touch`/`$(...)` payloads no longer executes; gate and field extraction unchanged. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * feat(hooks): explicit opt-in, plugin/CLI version fields, TELEMETRY.md Incorporates review feedback on the telemetry proposal: - Opt-in via UIPATH_TELEMETRY_ENABLED (default off; send only when "1"). Replaces the previous UIPATH_TELEMETRY_DISABLE off-switch with an explicit enable flag, which is what TELEMETRY.md documents. - Add pluginVersion (skillsVersion from version-manifest.json) alongside cliVersion. The two are designed to track each other, so sending both makes field drift visible. Read from the manifest, not git rev-parse (which yields "unknown" for marketplace installs). - Add toolUseId to each event: correlation key + deterministic ordering tiebreaker for same-millisecond events. Session-level metrics (turns, duration, time-to-first-skill, retries) are query-time aggregations over ai.session.id — no local state file needed. - Add TELEMETRY.md documenting opt-in, the emit gate, every field, privacy guarantees, and the correlation queries. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * feat(hooks): always emit every telemetry field with empty/null fallback Guarantee a stable event schema even when a payload field is absent: - Properties always appear; a missing source yields an empty string "" rather than being omitted. Deliberately NOT null — App Insights drops null-valued properties, which would make the field vanish from the event. - The durationMs measurement emits JSON null when duration_ms is absent or non-numeric, instead of defaulting to 0 (which would skew latency averages). - workspace_id (ai.user.id) is empty when cwd is absent, instead of hashing an empty string into a meaningless id. Verified with a minimal payload (no cwd/permission_mode/effort/tool_use_id/ duration_ms): all 13 property keys still present, missing strings = "", durationMs = null, body remains valid JSON. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * feat(hooks): align opt-out with uip CLI's UIPATH_TELEMETRY_DISABLED Replace the bespoke UIPATH_TELEMETRY_ENABLED opt-in with the uip CLI's existing UIPATH_TELEMETRY_DISABLED variable (packages/common/src/telemetry/ telemetry-init.ts), accepting "1" or "true" to disable. This gives a single control plane: a user who silenced CLI telemetry silences this hook too. Polarity note: this is opt-OUT (default attempted) vs the previous opt-IN. The default-on change is bounded — nothing transmits unless a connection string is configured, and we ship no default endpoint. Verified: unset and DISABLED=0 -> send; DISABLED=1 and DISABLED=true -> no send. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * feat(hooks): opt-in telemetry — send only when UIPATH_TELEMETRY_DISABLED=0 Telemetry is off by default. Reusing the uip CLI's variable name, the hook sends only when UIPATH_TELEMETRY_DISABLED is explicitly "0"; unset (default) or "1" sends nothing. Absent is treated as disabled — privacy-first default-off. Note this intentionally diverges from the CLI's own default for the unset case (the CLI sends when the var is absent); we keep the variable name but enforce opt-in. Verified: unset -> no send; =1 -> no send; =0 -> send. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * feat(hooks): include .cs (coded workflows) in the file-tool gate Edit/Write/Read/Glob/Grep on .cs files now qualify as UiPath events — .cs is the coded-workflow source. fileExt extraction already handled .cs generically. Verified: editing Workflow.cs emits with fileExt=.cs. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * feat(hooks): make plugin-usage telemetry hook fire-and-forget Declare the PostToolUse telemetry hook async so Claude Code never waits for it. The hook prints {async: true, asyncTimeout: 10000} right after the UiPath-attribution gate, so opted-out and non-attributable calls still exit synchronously in milliseconds while real emissions resolve the environment (~0.5s `uip login status`, hourly) and POST in the background. The detached curl subshell is kept as a flush-safety net so the POST stays non-blocking even if bash buffers the async directive. hooks.json timeout raised 5->10s to match asyncTimeout (10000ms), per the convention used by the official security-guidance async hook. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * fix(hooks): configure async via hooks.json field, not a stdout directive Per the hooks docs (code.claude.com/docs/en/hooks#configure-an-async-hook), a command hook is made non-blocking with the async: true FIELD in hooks.json — not by printing {async:true,...} to stdout (that is the SDK callback mechanism). Set async: true on the PostToolUse telemetry hook, drop the printed directive from the script, and revert the timeout to 5s (async makes the hook non-blocking regardless, and the detached curl keeps the script's own runtime under a second). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * chore(hooks): drop explicit timeout from async telemetry hook The hook is non-blocking ("async": true) and the detached curl keeps its own runtime under a second, so the explicit timeout added no value. Falls back to the command-hook default. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * feat(hooks): pipe telemetry to `uip track` instead of direct App Insights POST Replace the hand-built Application Insights envelope and curl POST with a flat JSON object piped to the hidden `uip track` CLI command (UiPath/cli#2600). The CLI now owns transport, the App Insights connection, the event name (uip.skills.tool-use), the authenticated cloud identity, and the source: "skills-plugin" dimension. The hook keeps its responsibilities: field derivation, value sanitization (san(): charset + length cap), the opt-in gate (UIPATH_TELEMETRY_DISABLED=0), the cached environment resolution, and the async/detached, never-fail posture. Drop what the CLI now owns: the connection-string env vars, the cwd SHA-256 hashing / anonymous ai.user.id, and the iso timestamp. durationMs is sent as a JSON number; sessionId moves from an envelope tag to a flat property. Update TELEMETRY.md: skills telemetry is now associated with the signed-in UiPath identity (no longer anonymous); describe the `uip track` hand-off in place of the direct App Insights POST. Opt-in and non-blocking guarantees unchanged. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * fix(hooks): refine telemetry field names, re-add userId, clarify version field Address App Insights review feedback on the uip.skills.tool-use event: - Rename fileExt -> fileExtension and os -> operatingSystem (full, unambiguous property names). - Re-add userId: SHA-256 (first 16 hex) of cwd — a stable, anonymous per-workspace id, distinct from the CloudUserId the CLI stamps. (Reinstates the cwd hashing that the uip-track migration had dropped.) - Rename pluginVersion -> skillsVersion. It reads skillsVersion from version-manifest.json (1.196.0), which tracks the CLI version via targetCli — NOT the .claude-plugin/plugin.json package version. Renaming removes the confusion of a "pluginVersion" that did not match the plugin package version. effortLevel and sessionId are unchanged: effortLevel reads the payload's effort.level (verified it populates when present; empty only when the payload omits effort), and sessionId passes through the Claude Code session_id verbatim. Update TELEMETRY.md properties table and privacy section to match. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * fix(hooks): add subagent context, drop fields the CLI tracker already owns Per App Insights review feedback on uip.skills.tool-use: - Add agentId/agentType from the PostToolUse payload. Present only when the tool call runs inside a spawned subagent (empty = main session); agentType is the subagent name (Explore / Plan / custom). Lets us split usage between the main loop and subagents. NOTE: the model id is NOT in the PostToolUse payload, so modelId cannot be sourced from the hook. - Remove cliVersion: the CLI tracker already records its own version as application_Version. Also drops the per-resolve `uip --version` subprocess. - Remove operatingSystem: the tracker records OS / client context by default. - Remove userId (SHA-256 of cwd): no longer needed; dropping it also removes the only cwd-derived value, so cwd is now never read at all. sessionId and toolUseId are unchanged — both pass the Claude Code payload values through verbatim (any odd values like `rerun2-*` come from the test harness generating the payload, not the hook). `source` is CLI-stamped, not hook-sent. All new fields pass through san() (charset + length cap) to keep the emitted JSON valid and injection-safe. Update TELEMETRY.md to match. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * fix(hooks): replace agentId/agentType with best-effort modelId Drop agentId/agentType; add a single modelId field instead. It is populated best-effort from the payload: an explicit `model` field if present, else a `claude-<family>` id token found anywhere in the payload, mapped to a short family name (opus / sonnet / haiku / fable). `model` is not a documented PostToolUse field, so modelId is empty when the payload carries no model id. Update TELEMETRY.md to match. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * fix(hooks): drop modelId from telemetry event Remove modelId (and the leftover agentId/agentType lineage) from the uip.skills.tool-use event and its derivation. Update TELEMETRY.md to match. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * feat(hooks): add subagentModel, subagentType, agentType to telemetry Extract three subagent fields from the PostToolUse payload (by key name, sanitized; empty when absent): - tool_response.resolvedModel -> subagentModel - tool_input.subagent_type -> subagentType - agent_type (top-level) -> agentType Update TELEMETRY.md to match. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * feat(hooks): track Agent spawns for UiPath + Claude built-in subagents Add an `Agent` case to the relevance gate so subagent-spawn events are emitted (populating subagentModel / subagentType). Track only when subagent_type is a UiPath agent (`uipath:` / `uipath-`) or a Claude built-in agent type (general-purpose, Explore, Plan, claude, claude-code-guide, statusline-setup, fork). Other plugins' agents (`<plugin>:<name>`) and user-defined custom agents are intentionally NOT tracked. subagent_type is now read once in the gate and reused. Document the Agent trigger in TELEMETRY.md. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * fix(hooks): region-scope telemetry field extraction; add schemaVersion Field extraction grepped the whole payload, so free-form customer content (prompts, command lines, stdout/stderr, file contents) could false-match a field: a stdout containing "success":false, an Agent prompt naming `uip solution publish` / `.flow"` / `"resolvedModel":"x"` / `"agent_type":"y"` all leaked into the emitted map (tool_input precedes tool_response, first match wins). Replace the whole-payload greps with one string-aware awk pass that walks the JSON once, tracks brace/string depth (honoring \" and \ escapes), and pulls each field only from its region: - envelope (top-level): toolName, toolUseId, sessionId, permissionMode, durationMs, effortLevel (effort.level), agentType - tool_input: skillName, uipSubcommand (from command), fileExtension (from file_path), subagentType - tool_response: outcome (interrupted/success), subagentModel (resolvedModel) The relevance gate is scoped the same way (uip command vs tool_input.command, file extensions vs tool_input.file_path), so content can no longer over-attribute. Nested/in-string content can never satisfy a top-level match. Also: - Add schemaVersion (constant 1) so App Insights can segment churned schemas. - Define the canonical key set once and assemble JSON by iteration (fixed order, every key always emitted) instead of a hand-concatenated printf. - outcome computed from tool_response only: {ok, failure, interrupted, unknown}; ok is the default for tools with no status, unknown only when no tool_response exists; content never flips it. - Normalize subagentModel to a family (opus/sonnet/haiku/fable; other), dropping the context-window marker (claude-opus-4-8[1m] -> opus). Keeps the flat key:value contract to `uip track`, the opt-in gate, the detached non-blocking subshell, cached env resolution, and san() bounding. Pure bash + grep/sed/awk (no jq/node/python), cross-platform. TELEMETRY.md updated to match (region scoping, outcome semantics, subagent-field meanings, schemaVersion). No change to the `uip track` CLI side. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * refactor(hooks): split telemetry hook into named functions Restructure send-telemetry.sh into small, single-purpose functions driven by main(), so the flow reads as a pipeline instead of one long linear body: extract_fields, read_fields, is_uipath_call, resolve_environment (+ cache_val), derive_fields, compute_outcome, model_family, read_skills_version, san, build_event_json. Pure transforms return via stdout (compute_outcome, model_family, san, build_event_json); procedures with side effects set documented globals (read_fields, resolve_environment, derive_fields). The string-aware awk extractor is unchanged, kept inline in extract_fields. No behavior change — kept as a single self-contained hook (matches the repo convention; no sourcing/path-resolution risk on the PostToolUse hot path) and the 51-assertion test harness still passes. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

refactor(uipath-planner): group case-only files and evals into case/ subfolders (#2929) * refactor(uipath-planner): group case-only files into case/ subfolders CODEOWNERS gave the Case Management owners co-ownership of the planner's case surface one file at a time. Every new case-only file meant another per-file line, so the block grew without bound and drifted whenever a file was added or renamed. Move the five case-only files into `case/` subfolders that mirror the existing skill layout, so ownership can be expressed per folder: references/case/ case-design-lane-guide.md, case-design-layers-guide.md assets/templates/case/ case-sdd-template.md, sdd-viewer.html scripts/case/ audit_sdd.py Six per-file CODEOWNERS lines collapse to three folder lines, and a new case-only file is covered by dropping it in the matching folder — no CODEOWNERS edit at all. Category-mirrored folders rather than one flat skills/uipath-planner/case/ keep the references/ + assets/templates/ + scripts/ layout that .claude/rules/skill-structure.md mandates. The lane guide resolves reference paths against the skill base directory and forbids hunting for files, so every pointer to a moved file is updated: SKILL.md, both moved guides, the moved template, sdd-generation-guide.md, product-selection-guide.md, audit_sdd.py's LAYERS_MD lookup, and three test files. Same-directory sibling links inside references/case/ are unchanged. Verified: skills:check-links resolves all 6461 links; skills:validate and skills:build pass for both flavors; audit_sdd.py runs from its new home with model checks armed; planner case tests pass, including the twin-parity self-containment check that reads the moved files. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * chore(uipath-planner): trim planner from case eval ownership Drop the explanatory comment block above the case folder rules — the paths carry the intent, and the block was three lines of prose in a file that is read as data. Remove @RaduAna-Maria from the case-related eval entries so the Case Management owners review those on their own. `_shared/` is included: every task that consumes it is a case task, so it is case-only in practice. The three skill-side `case/` folder rules and the general /tests/tasks/uipath-planner/ rule keep @RaduAna-Maria unchanged. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * refactor(uipath-planner): group case evals into tests/.../case/ Same reason as the skill-side `case/` folders: ownership was declared one eval directory at a time, so the block grew with every case task added. Move the nine case evals — bpmn_vs_case_management, the six case_design / case_finalize_draft dirs, case_sla_response_map, and deferral_single_case.yaml — under tests/tasks/uipath-planner/case/. Nine CODEOWNERS entries collapse to one, and a new case eval is covered by landing it in the folder. `_shared/` deliberately stays at the suite root. Its __init__.py bridges the uipath-maestro-case and uipath-planner checker packages by that exact path, and test_shared_twins.py pins sdd_check.py byte-identical across the two suites; moving it would force an edit to the maestro-case suite and leave the bridge asymmetric. It keeps its own CODEOWNERS line, so the block goes 9 -> 2. Because `_shared/` did not move, the four `$SKILLS_REPO_PATH/.../_shared/` references in the case task YAMLs need no change. Two path computations shift by one level and are updated: the three moved checkers' sys.path bootstrap (parents[1] -> parents[2]) and test_finalize_checkers.py's lookup of the picker and reject checkers. case_sla_response_map/ had no CODEOWNERS entry before and is now covered by the folder rule. Per the earlier decision, the unified rule keeps @jundayin, so no reviewer loses access; bpmn_vs_case_management and deferral_single_case gain them. Verified: 34 task YAMLs before and after, all nine case tasks still found by the recursive glob the Makefile and CI use; the three moved checkers import `_shared` and run; _shared suite passes (29 tests), including test_finalize_checkers.py subprocessing the moved checkers, test_shared_twins.py and test_case_twin_parity.py; per-task tests pass from their new locations. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * chore(uipath-planner): drop explanatory comment from case eval rules Keeps the earlier decision to hold prose out of CODEOWNERS. The reason `_shared/` stays at the suite root lives in the commit history and the PR, not in the file the review tooling reads as data. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>

fix(uipath-planner): write the SDD skeleton before Phase 3, raise SDD turn budgets (#2850) Run 2026-08-27_04-13-44 lost skill-sdd-integration-gap-detection and skill-sdd-integration-need-driven-selection to the per-turn watchdog: both turns were hard-killed at 1800s with no SDD on disk (ERROR, score 0.000). Neither agent ever called Write — 93% / 86% of each budget went to reasoning blocks, and both agents' own progress lists scheduled "Write SDD to disk" as their final task, so the only gradeable artifact was the one thing the kill took out. Skill: - Phase 3 gains Step 0, a hard gate: write the skeleton (header + Planner Handoff header/marker with Status: draft + Decisions Made / Recommended Scope + Phase 1/2 sections) BEFORE generating any Phase 3 section, then append sections as they are generated. This promotes the buried write-early blockquote into an executable step. - The Step 0.5 progress list now carries "Write SDD skeleton to disk" as task 4 and renames the terminal task to "Finalize SDD (Status: ready)"; new Rule G-9 forbids reordering the write to the end. The old list taught the deferral the traces show. - Step 2 item 6's collision check now runs before the Step 0 write — moving the write earlier moved the clobber risk earlier with it. - Level 0 estate sweep is capped at one round: an empty estate is a final answer, and a rejected flag is not retried with a guess. Both runs burned reasoning cycles on repeat sweeps (one guessed `--filter`, rejected as ValidationError; another re-ran the same list with client-side filtering). Tests: - Both tasks move to the proven constraint_gate budget (2700s turn / 3600s task) from 1800s/2700s, which also clears the orchestrator's inverted-limits warning. - Both prompts gain the guard the passing siblings carry: name the SDD file, load the skill, no `uip` commands, the SDD is the only deliverable. - gap_detection.yaml gains the required mode:build tag. Not yet re-run under coder-eval; needs a passing-run claim before merge. Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>

fix(rpa): discovery agent writes its own context files; gate empty projects (#2646) * fix(rpa): discovery agent writes its own context files; gate empty projects The discovery subagent had no write tools, so it returned the context document and the main agent wrote the files — an extra round-trip that also let the write get skipped whenever the main agent moved on. The subagent now owns both outputs. It was also spawned for new and freshly-scaffolded projects, where it can only produce a document of empty tables. The greenfield check only covered a missing project.json, so a scaffolded-but-empty project still paid for a full discovery pass. - agent: add Write/Edit tools; new Step 5 writes .claude/rules/project-context.md + AGENTS.md (marker merge logic moved here from SKILL.md); Step 6 returns a context-files: status line plus the document so the main agent keeps session context without re-reading - agent: new Step 2 gate returns SKIP: <reason> for no project.json, zero authored .xaml/.cs files, or a lone untouched scaffolded entry point - SKILL.md: new "Skip gate" section applies the same three conditions before spawning; discovery flow only writes files itself when the agent reports context-files: not-written (read-only subagent hosts such as UiPath Autopilot), and treats a SKIP: return as a gate trip - execution-maps-guide, README: follow the reworked flow Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * fix(rpa): gate covers library and test scaffolds; align exclusion lists Verified against fresh Studio 26.0.201 blank projects: libraries scaffold NewActivity.xaml (not NewActivity1.xaml) and blank test cases ship a Comment activity inside the root Sequence, so both slipped past the gate. Entry-point list now names all four scaffold shapes; content test ignores Comment activities and ViewState metadata. Exclusion lists in SKILL.md and the agent unify to all dot-directories + obj/ + bin/, covering .templates/, .tmh/, .project/ seen in fresh scaffolds. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * docs(rpa): tighten skip-gate wording Same gate semantics, terser prose per token-optimization rules: scaffold entry-point names and the untouched-content test move out of the overlong table row into two short lines. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>

feat(hooks): accept Autopilot/Delegate tool names in telemetry gate (#2010) UiPath Autopilot / Delegate honor hooks.json with the same envelope and lifecycle events as Claude Code, but rename their shell and file tools: ExecuteBashCommand / ExecutePowershellCommand (vs Bash / PowerShell) and ReadFile / WriteFile / EditFile / LsDirectory (vs Read / Write / Edit / Glob / Grep). Their tool_input still carries command / file_path, so the existing attribution and uipSubcommand / fileExtension derivation fire once the renamed names are gated. Add the renamed names to the attribution gate and field derivation in both twins (send-telemetry.sh / .ps1), kept behaviorally identical. The anchored `uip` matcher is deliberately left unchanged — it already matches the same `uip ...` command strings these agents carry, and loosening it to a bare substring would over-attribute (e.g. "equipment") and break `$UIP` detection, contradicting the documented region-scoping design. Document the rename in TELEMETRY.md (trigger table + cross-agent section) and add parametrized tests covering the new tool names plus an over-attribution guard. Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>