@uipath/delegate-sdk 1.204.0-preview.20261016094708 → 1.204.0-preview.20261019134103

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md CHANGED
@@ -177,7 +177,7 @@ agent.onEvent((event) => {
177
177
  await agent.initialize({
178
178
  backendUrl: 'https://cloud.uipath.com/<org>/<tenant>/delegate_',
179
179
  auth,
180
- model: 'claude_sonnet_5',
180
+ model: 'claude_sonnet_5_5',
181
181
  enableComputerUse: true,
182
182
  keepInteropAlive: false,
183
183
  });
@@ -510,7 +510,7 @@ const checked = await verify(client, { claims: [{ id: 'c1', claim: 'The invoice
510
510
  ```
511
511
 
512
512
  - Requests and responses use the backend's **snake_case wire names** (`top_k`, `model_version`, `rubric_version`, `usage.total_tokens`) unchanged. Every question needs its `type`. The backend refuses unknown fields and caps a request at 128 KiB and 64 questions, candidates or claims.
513
- - `model` picks a catalog model (`jev_1_13`, `gemini_3_6_flash`, `gpt_5_6_luna`, `claude_sonnet_5`); omit it for the server default. The backend never substitutes another model.
513
+ - `model` picks a catalog model (`jev_1_13`, `gemini_3_6_flash`, `gpt_5_6_luna`, `claude_sonnet_5_5`); omit it for the server default. The backend never substitutes another model.
514
514
  - The third argument takes `{ signal, timeoutMs }`; pass `undefined` for the defaults.
515
515
  - A non-2xx answer rejects with `EvaluationRequestError`: `operation`, `status`, `detail`, `validationIssues`, the `BackendRequestError` as `cause`, and a `reason` — `invalid_request` (422), `model_unavailable` (403, 503), `rate_limited` (429), `provider_error` (502), `timeout` (504), `unauthorized` (401) or `other`. Narrow with `isEvaluationRequestError(error, 'invalid_request')`.
516
516
  - A verdict or probability is a signal, not permission to act.
package/dist/index.mjs CHANGED
@@ -1,4 +1,4 @@
1
1
  [diffend] Oversized file quarantined before diffing.
2
2
  name: package/dist/index.mjs
3
- size: 56477195 bytes
4
- sha256: 8ab9b3f4775fe420057ec26851e9c0381f16b3eb3f985f70659f64dcdfe4a0a7
3
+ size: 56509632 bytes
4
+ sha256: 807a7e0485cddf85ca98fdbd9e1293f3f379ba16b18366b6c79cc96ea68684bd
@@ -22,7 +22,7 @@ Every recipe block below is tagged `usage`: an **argument template**, not a runn
22
22
  Shared rules (both platforms):
23
23
  - Prepend the resolved binary + `-nostdin` (recipes elide both): `"$FFMPEG" -nostdin <args>`. `-nostdin` goes before `-i` — without it ffmpeg inherits parent stdin and hangs to timeout. `ffprobe` skips `-nostdin`.
24
24
  - Recipes show `libsvtav1` (bundled + most modern builds); with a full PATH ffmpeg prefer `-c:v libx264 -crf 20 -preset medium` (wider playback). Missing encoder (`Unknown encoder`) → check `ffmpeg -hide_banner -encoders`, pick an available one (codec rules below).
25
- - Timeout: generous (max 600s). Re-encode of a source ≥ 60s → delegate to a subagent (Long re-encodes below), never one blocking call.
25
+ - Timeout: generous (max 1800s). Re-encode of a source ≥ 60s → delegate to a subagent (Long re-encodes below), never one blocking call.
26
26
  - Verify before reporting done: `ffprobe` reads the output, size > 0 (trims/concat: duration ≈ expected). Report output path + size.
27
27
 
28
28
  ### macOS invocation (`ExecuteBashCommand`)
@@ -59,7 +59,7 @@ Invoke-FF $FFMPEG @("-nostdin","-i",$in,"-ss","00:01:30","-to","00:02:15","-c:v"
59
59
 
60
60
  ## Long re-encodes — delegate to a subagent
61
61
 
62
- Trigger: any re-encode (anything not pure `-c copy`) of a source ≥ 60s (ffprobe) — compress, format/codec convert, gif, filtered concat, speed change, resize, subtitle burn-in. These outlast the 600s shell cap and give no feedback. Stream-copy ops (`-c copy` trim/convert/merge) stay fast: one blocking `Invoke-FF` call in the main loop, no subagent.
62
+ Trigger: any re-encode (anything not pure `-c copy`) of a source ≥ 60s (ffprobe) — compress, format/codec convert, gif, filtered concat, speed change, resize, subtitle burn-in. These can outlast the 1800s shell cap and give no feedback. Stream-copy ops (`-c copy` trim/convert/merge) stay fast: one blocking `Invoke-FF` call in the main loop, no subagent.
63
63
 
64
64
  Don't encode in the main loop. Spawn an `Agent` (`agent_type: "general"`, `automation_mode: none`, `description: "Encode <op>"`) that owns the whole launch → poll → verify cycle and returns one line. Keeps polling off the main turn loop for every long re-encode — unconditional, no permission ask, no mode question.
65
65
 
@@ -189,7 +189,7 @@ Match your symptom, apply the fix. First table applies everywhere; check the Win
189
189
  |---------|-------|-----|
190
190
  | `Unknown encoder 'libx264'` | bundled (GPL-free) build has no x264/x265 | Re-encode with `libsvtav1`; `libopenh264` for H.264 |
191
191
  | Hangs immediately, no progress | ffmpeg blocked on inherited stdin | Add `-nostdin` before `-i` |
192
- | Long encode killed at 600s / no feedback | encoded in the main loop over the shell cap | Delegate via `Agent` (`agent_type: general`) (Long re-encodes) |
192
+ | Long encode killed at 1800s / no feedback | encoded in the main loop over the shell cap | Delegate via `Agent` (`agent_type: general`) (Long re-encodes) |
193
193
  | `-c copy` fails | codec/container mismatch | Re-encode with `libsvtav1` |
194
194
  | Output not written / permission denied | target dir not writable | Write to a user dir (macOS `$TMPDIR`, Windows `$env:TEMP`), then move |
195
195
 
@@ -9,7 +9,7 @@ Use this skill when the session provides `TaskListPath` (project-bound or standa
9
9
 
10
10
  ## When To Use
11
11
 
12
- Open a task list for multi-step work: 3 or more distinct steps, or work that spans turns. Each row is one task; its `stage` field names its stage by id. Write the rows before executing, then keep each row current — `in progress` when you start it, `confirmed` only when its outcome is verified. Single-step or question-only requests need no task list.
12
+ Open a task list for multi-step work: 3 or more distinct steps, or work that spans turns. Each row is one task; its `stage` field names its stage by id. Open it in the reply that makes your first work call, the way the Task List rules in your instructions say, with the steps you know now — rows for steps the work reveals later are added the same way — and keep each row current the same way — `in progress` when you start it, `confirmed` only when its outcome is verified. Single-step or question-only requests need no task list.
13
13
 
14
14
  Stages are independent workstreams and may progress in parallel — delegated tasks complete on their own time. Task order inside a stage is presentation order, with one exception: a plan-seeded stage's tasks follow the plan's execution order. Never open a parallel stage for work an existing stage already tracks — work the existing tasks.
15
15
 
@@ -34,15 +34,21 @@ Everything below applies identically to whichever list the row belongs to: subst
34
34
 
35
35
  Never create `ba-task-list.md`.
36
36
 
37
+ ## Statuses, Rows, Stages And Details
38
+
39
+ Write statuses, new rows, new stages and a task's details (`description`, `answer`, `provenance`) the way the Task List rules in your instructions say: a ```tasklist reply block the app applies, or file edits. Edit Discipline is for file edits; the file format, reads and the user's side of the list hold either way.
40
+
37
41
  ## Read Discipline
38
42
 
39
- The rollup already says where you are and which id to edit; do not read the file to find out.
43
+ The rollup says where you are and which row ids to change; do not read the file for either. Statuses, new rows and new stages need nothing else from it: the app keeps the rest of the list as it is.
40
44
 
41
- When edits need exact text — a row's line, or its `task-record` for a description, answer, userNote or provenance edit — read the whole list with one `ReadFile` of `TaskListPath` before the first edit (`offset` and `limit` on a large one), however many rows the step changes. Never `Grep` the task list. One read per step: none between the edits, none after them.
45
+ Read the list only for text you need and have not seen: an `EditFile` anchor in a `task-record` body, in a list you did not write or that the user changed since, or a detail you rewrite and must keep part of. One `ReadFile` of the whole `TaskListPath` (`offset` and `limit` on a large one), never a `Grep`, in a response of its own; the edits of that step follow in the next response. One read per step: none between the edits, none after them.
46
+
47
+ The app's write-back after each of your edits adds `schemaId`, stamps on stage entries, and a stamp `task-record` for each task you changed; it does not rewrite row lines or record bodies you wrote. The text you wrote is the text to anchor on.
42
48
 
43
49
  - A task with a file keeps its details there: read that file too.
44
50
  - If `TaskList` is missing, stale, or insufficient, use `TaskListPath` and file reads rather than guessing.
45
- - `TaskListFile: does not exist yet` → no list has been written. Do not read `TaskListPath`; the Row-Building Workflow's `WriteFile` creates it.
51
+ - `TaskListFile: does not exist yet` → no list has been written. Do not read `TaskListPath`; opening the list (Row-Building Workflow) creates it.
46
52
 
47
53
  ## Markdown Format
48
54
 
@@ -70,7 +76,7 @@ updatedAt: 2026-09-25T14:03:00+03:00
70
76
  ```
71
77
  ````
72
78
 
73
- Stages live in the frontmatter `stages:` list, in order. Each has an `id` — its title's words in lowercase, joined by `_`, fixed once written; rows name the stage by it — a `title` in sentence case (the panel prints it as written), an optional `description`, and, when it has to wait for other stages, a `dependsOn` list of their ids. For a stage you create, write one general sentence, ≤ 100 characters, no specifics, unless the domain skill supplies a different description policy.
79
+ Stages live in the frontmatter `stages:` list, in order. Each has an `id` — its title's words in lowercase, joined by `_`, fixed once written; rows name the stage by it — a `title` in sentence case (the panel prints it as written), an optional `description`, and, when it has to wait for other stages, a `dependsOn` list of their ids. For a stage you create, write one general sentence, ≤ 100 characters, no specifics, unless the domain skill supplies a different description policy. A stage first named by a row's `[stage:: …]` gets its entry from the app: named by a title (`[stage:: Follow-ups]`) it keeps that title and gets the id `follow_ups`; named by an id it is titled from the id's words; either way no description.
74
80
 
75
81
  The domain skill's description policy applies to both rows and stages during creation, rebuilds, and synchronization. Leave descriptions absent where that policy uses localized panel copy. Preserve existing row and stage descriptions, including in older projects; never add, rewrite, or remove them during status, answer, or provenance updates. A stored description takes precedence over localized panel copy.
76
82
 
@@ -109,19 +115,22 @@ A valid row has a non-empty title, exactly one non-empty `id`, no duplicate id e
109
115
 
110
116
  A task's details live in its `task-record` unless its row says otherwise:
111
117
 
112
- - `[sourceType:: path] [sourcePath:: tasks/<task id>.yaml]` — a file of its own in the `tasks/` folder beside `task-list.md`, for details that outgrow a few lines. The file holds the `task-record` keys (`description`, `answer`, `userNote`, `provenance`) at the left margin, multiline values indented two spaces, with no fence and no stamps: the stamps stay in the task's `task-record`. Write the file, then add the two fields to the row; details still in the `task-record` move into the file on the app's next write. From then on edit the file, never a copy in `task-list.md` — the app reads it every turn and stamps your edits to it. `sourcePath` names a file directly in `tasks/`, ending `.yaml`; the app refuses any other.
118
+ - `[sourceType:: path] [sourcePath:: tasks/<task id>.yaml]` — a file of its own in the `tasks/` folder beside `task-list.md`, for details that outgrow a few lines. The file holds the `task-record` keys (`description`, `answer`, `userNote`, `provenance`) at the left margin, multiline values indented two spaces, with no fence and no stamps: the stamps stay in the task's `task-record`. Write the file, then add the two fields to the row; details still in the `task-record` move into the file on the app's next write. From then on the details live in the file, never in a copy in `task-list.md` — the app reads it every turn and stamps changes to it. `sourcePath` names a file directly in `tasks/`, ending `.yaml`; the app refuses any other.
113
119
  - `[sourceType:: external] [sourceSystem:: <system URL>] [sourceId:: <record id>]` — a record in another system, such as a Jira issue. Nothing reads or writes that system yet: add the link only when the user gives you one, and keep the details in the `task-record` as the local copy.
114
120
 
115
121
  ## Edit Discipline
116
122
 
117
- Use `EditFile` for updates to an existing task list. Use `WriteFile` only for the row-building workflow below or when replacing a non-empty file with no recognized rows after reading it.
123
+ When the Task List rules give you the ```tasklist block, statuses, new rows and stages, and a task's details are block lines there, never an `EditFile`. Use `EditFile` only when a requested change has no block syntax: existing-stage metadata or renames/reordering; existing-row title, stage, dependencies, status color, source fields, moves/reordering, or removal. Only those edits follow the rules below, with the normal file-access rules. With file edits, `EditFile` writes a task's details — `description`, `answer`, `provenance` — in its `task-record` or task file, by the rules below. `WriteFile` only where the Task List rules open the list with it, or to replace a non-empty file with no recognized rows after reading it.
124
+
125
+ Record edits ride with the work too: send them in the same reply as the next work call, never in a reply of their own. Calls in one reply run in the order listed — writes one after another, reads alongside the first write — so several `EditFile` calls on the list in one reply are safe; never put a `ReadFile` of the list in the same reply as an edit of it.
118
126
 
119
- - A status change (pending → in progress → confirmed) edits the row's line: `old_content` runs from `[id:: …]` to `[status:: …]`, or to `[statusColor:: …]` when the row has one — unique in the file — and `new_content` is that span with the new status. The app sets the `[ ]` / `[x]` box from the status.
120
- - A detail change (`description`, `answer`, `provenance`; `userNote` is the user's) edits the task's `task-record`: `old_content` is the key and its value (`answer: |` and the lines under it), never the stamps closing the block. A task without a record gets one: a new block right under `## Task records` (anchor on the heading line; no heading yet → add it after the last row).
121
- - Several rows change in one step — the row you finished and the row you start, or every row a domain skill syncs after its writes — → one `EditFile` per run of neighbouring rows, plus one per changed record, all in one response, with no reads in between. Never rewrite the whole file to change a few rows.
127
+ - A detail change (`description`, `answer`, `provenance`; `userNote` is the user's) edits the task's `task-record`: `old_content` is the key and its value (`answer: |` and the lines under it), never the stamps closing the block and never the closing fence — the app writes stamps between the last key and the fence after every edit, so an anchor that reaches the fence fails. To add a key, anchor on the last line of the key before it and append the new key after that line. A task without a record gets one: a new block right under `## Task records` (anchor on the heading line; no heading yet → add it after the last row). A task you changed always has a record once the app stamped it; a record with stamps only is where your `answer` goes, above the stamps.
128
+ - Several records change in one step — every row a domain skill syncs after its writes — → one `EditFile` per changed record, all in one reply, with no reads in between, and their statuses the way the Task List rules say. Never rewrite the whole file to change a few records.
129
+ - Every edit a step needs goes out in one response, as consecutive `EditFile` calls on the same file: the app runs them one after another in the order listed, each on the result of the one before. Sending one edit, waiting for its result, then sending the next costs a model turn and changes nothing.
130
+ - Edits in one reply never overlap: no two `old_content` spans share text, and none includes a line another edit changes. Two neighbouring rows that both change are one edit.
122
131
  - Stamps (`updatedBy` / `updatedAt` closing a `task-record`, and on a stage's `stages:` entry) are the app's: never write, change or remove one. The app stamps what you changed once the edit lands, which is why a detail edit stops before them.
123
- - Adding rows to an existing list: one `EditFile` whose `old_content` is the row line the new rows follow and whose `new_content` is that line followed by the new rows, plus one adding their records under `## Task records`. A new stage is one `EditFile` on the frontmatter `stages:` list.
124
- - A successful `EditFile` result is the verification — no verifying re-read. `TaskListRepair` catches drift on the next turn. If `EditFile` reports that `old_content` was not found or the file changed, `ReadFile` the list again and retry that one edit once; do not fall back to a whole-file rewrite.
132
+ - Rows and stages are added the way the Task List rules say. A stage's description or `dependsOn` added later is one `EditFile` on its `stages:` entry, after the one read that frontmatter needs, only when the user asks for it.
133
+ - A successful `EditFile` result is the verification — no verifying re-read; the next turn's rollup shows every change. `TaskListRepair` catches drift on the next turn. If `EditFile` reports that `old_content` was not found or the file changed, `ReadFile` the list again and retry that one edit once; do not fall back to a whole-file rewrite.
125
134
 
126
135
  Preserve unrelated content:
127
136
 
@@ -135,8 +144,8 @@ Preserve unrelated content:
135
144
  When the active domain does not declare a project-file template, or when a non-empty file has no recognized rows:
136
145
 
137
146
  1. Build the task list rows from the active domain skill or user request.
138
- 2. Write one `task-list.md` with frontmatter listing each stage with its id and title, then the top-level task rows. Include one-sentence row and stage descriptions unless the domain skill's description policy leaves them absent. Add `## Task records` and a `task-record` only for tasks with a description, answer, or provenance to record.
139
- 3. Include stable ids on written rows.
147
+ 2. Open the list in the reply that makes the first work call, the way the Task List rules say: each stage with a one-sentence description unless the domain skill's description policy leaves it absent, its rows with stable ids, the first row `in progress`.
148
+ 3. Record a task's description, answer or provenance the way the Task List rules say, with the next work call; with file edits, under `## Task records` only once the row exists, in a later reply.
140
149
  4. Do not duplicate domain policy here; this skill owns only the generic file protocol.
141
150
 
142
151
  ## Working With The User On The Same List
@@ -169,6 +178,6 @@ in the conversation, and the panel keeps a copy in the row's `userNote`.
169
178
  Every task list update runs these steps, including a domain skill's sync after its own writes: the domain skill says when to sync and what the rows say; this skill says how.
170
179
 
171
180
  1. Finish the related project-file or wiki writes and collect every task list change they require.
172
- 2. Get every affected row's exact text before the first edit (Read Discipline): one `ReadFile` of the whole list.
173
- 3. Compute each affected row's final line and `task-record`. Set answer and provenance together when content was just captured into project files; leave `description` as written. Use status labels consistently with `TaskList.statusPresets` or frontmatter presets.
174
- 4. Apply one targeted `EditFile` per row, all in one response. The results are the verification; do not re-read.
181
+ 2. Get the text the changes need (Read Discipline): the records you wrote are known; one `ReadFile` of the whole list, in a response of its own, only for text you have not seen.
182
+ 3. Compute each affected row's final `answer`, `provenance` and status. Set answer and provenance together when content was just captured into project files; leave `description` as written. Use status labels consistently with `TaskList.statusPresets` or frontmatter presets.
183
+ 4. In one reply: every changed record and status, the way the Task List rules say — with file edits, one targeted `EditFile` per changed record. No verifying re-read.
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  name: uipath-taskautomation
3
3
  friendly_name: UiPath Task Automation
4
- version: 0.23.0
4
+ version: 0.25.0
5
5
  description: "Convert the deterministic UI actions Delegate just performed into a UiPath coded workflow (C# CodedWorkflow) scaffolded as a standalone project via the bundled uip CLI. Trigger on: turn this into a workflow, make this repeatable in UiPath, generate a coded workflow, automate this in Studio, save these steps as an automation."
6
6
  icon: FaCode
7
7
  color: 1F6FEB
@@ -95,7 +95,8 @@ Then read the `step` records of the turn range, in execution order (by `i`, per
95
95
  - `turnId` — which turn produced the step; this is what you slice on.
96
96
  - `action` — canonical action type; `handling` per `references/action-activity-map.json`.
97
97
  - `target` — the resolved target, inline on the step (there is no shared `elements[]`), or absent with `noSelector: true` when the action targeted something no selector resolved for.
98
- - `value` — the payload data the activity needs (keys, selected item, URL, or an Orchestrator credential's asset name). `valueRedacted: true` → the value was never written to disk: typed, pasted and dialog text is withheld unless it is a URL, and so is any value whose target looked secret-bearing. Make it a spec Input (`${name}`); ask the user only for an example value, never guess, and route a credential through `GetCredential` (see Security).
98
+ - `value` — the payload data the activity needs (keys, selected item, URL, or an Orchestrator credential's asset name). `valueRedacted: true` → the value was never written to disk: typed, pasted and dialog text is withheld unless it is a URL, and so is any value whose target looked secret-bearing. Make it a spec Input (`${name}`); ask the user only for an example value, never guess, and route a credential through `GetCredential` (see Security). The one exception is an `execute_js` step, whose missing script is an unresolved step, not an Input (Phase 2).
99
+ - `valueMasked`, `valueTruncated` — a stored `value` that is not the whole of what ran. `valueMasked: true` → the value is stored, but a secret in it was replaced with `***` (URL credentials, an `execute_js` literal, a long digit run in a key press): never type or replay the `***`; that part is an Input, a credential through `GetCredential`. `valueTruncated: true` → the value was cut short (`valueLength` is its full length) and the rest is unknown: a step that depends on the missing part, such as an `execute_js` change past the cut, is an unresolved step under `## Open questions`, never authored from the fragment.
99
100
  - `operands` — what the action actually did beyond its type and value: click type and modifiers, `clearBeforeType`, a drag's destination, a credential step's per-field selectors and `credentialFolder`, a paste's `contentType`, `print_to_pdf`'s page options, `get_selected_text`'s `preserveClipboard`, `handle_dialog`'s `dialogResponse`, and `open`'s `openReason` (`launch` | `attach` | `restore`). **Carry every operand present into the spec step.** Dropping one yields a workflow that reads as complete and is not: every click becomes a left click, a drag keeps its source and loses its destination, and a launch replayed as an attach fails on a machine where the app is not already running.
100
101
  - `purpose` — the AppAct call's `description`; carry it into code comments and the Phase 7 report. Absent when it read as credential-bearing.
101
102
  - `proseMasked: true` — this step's prose (its `purpose`, its `targetDescription`, its target's `description`, or a credential-field operand) was screened: withheld whole, or masked in place. It separates "the agent said nothing" from "what it said is not in this file" — do not read a missing description as an element that never had one.
@@ -117,7 +118,7 @@ Coordinate points do not port; never emit them. A step's target sits on the step
117
118
 
118
119
  Targets are repeated verbatim on every step that used the same element, by design — there is no element registry to join against. Count repeats, and spot the elements worth naming once in the spec, by grouping on `uipathSelector`.
119
120
 
120
- **Prefer a harvested selector over the captured one.** Phase 1 overlaid it, joined to it by `i`; list it first and keep the step's captured selector as the first fallback — both selectors go into the spec's fallback list rather than one silently replacing the other. A harvest usually fixes what the capture pinned by accident: a window title the app happened to show (`title='Untitled - Notepad'`) breaks the whole selector once the document or folder changes, and on a Win32 or WinUI 3 desktop app that window part is often all a harvest improves. Its gate checked it against the ancestry captured with the element — a real check, but **not** a runtime one — so it is unproven until the Phase 6 smoke run hits it. Its own `selectorRedacted` and `reasoningMasked` mean what they do on a step.
121
+ **Prefer a harvested selector over the captured one.** Phase 1 overlaid it, joined to it by `i`; list it first and keep the step's captured selector as the first fallback — both selectors go into the spec's fallback list rather than one silently replacing the other. A harvest usually fixes what the capture pinned by accident: a window title the app happened to show (`title='Untitled - Notepad'`) breaks the whole selector once the document or folder changes, and on a Win32 or WinUI 3 desktop app that window part is often all a harvest improves. Its gate checked it against the ancestry captured with the element — a real check, but **not** a runtime one — so it is unproven until the Phase 6 smoke run hits it. Its own `selectorRedacted` and `reasoningMasked` mean what they do on a step. Use it as written: never rewrite an attribute (`aaname` → `title`), add a child tag, or re-anchor it. The one edit is a per-run value: put the spec Input in its place (`$"...{arg}..."`) or wildcard the part that varies, as `references/coded-workflow-authoring.md` § Elements says. Any other edit leaves a selector that is neither the harvest nor the capture, and nothing has checked it.
121
122
 
122
123
  A `harvest-refused` record's `refusedProposals` are selectors the gate rejected and **must never be used for replay**; their reasons say what about the element could not be pinned down — context for the Phase 3 question.
123
124
 
@@ -131,6 +132,8 @@ A step with `noSelector: true` has no strict target. Work down this ladder befor
131
132
  2. Its `target.description`, when a target resolved and carried one, or **`step.targetDescription`** — the agent's own words for what it was aiming at, written precisely when no selector was persisted: either the capture resolved nothing (`noSelector: true`) or the caller opted out of capturing (`noSelector` absent). Tighten it into a noun phrase before using it as a semantic selector, and never treat it as proven. A semantic-only target also needs the semantic service, which fails outright when the Robot is not connected to Orchestrator (`Cannot authenticate, not connected to Orchestrator` in `UIAutomation.log`), so it is the fallback, never a substitute for a capture.
132
133
  3. Only if none of these yields a target: carry the step into the Phase 3 spec marked unresolved, and let the user decide there — drop it, supply a description, or redo that one step via AppAct. Never invent a selector, and do not stall the pipeline on it.
133
134
 
135
+ **An `execute_js` step that changed the page is an action with no target.** A script that set a value, checked a box, clicked or dispatched an event did what a UI activity has to do at run time. Each element it changed is its own step, so a script that filled three fields is three steps: map each to the activity for that change (`TypeInto`, `SelectItem`, `Check`, `Click`) and capture its element live (rung 1). An element whose capture fails is an unresolved step (rung 3), never left out and never a semantic-only stand-in: a description cannot prove a value was set. A script that only read the page maps to nothing. A change none of those activities makes (a `form.submit()`, DOM nodes inserted or removed, a storage write, a component API call) is an unresolved step (rung 3) under `## Open questions`, never forced into one. **An `execute_js` step with `valueRedacted: true` and no `value` has no script to read**, so what it changed is unknown: leave it unresolved under `## Open questions`, naming the step and what it was for (its `purpose` and target description, when the log keeps them), and re-derive its effect live or ask the user before writing any activity for it. Never turn it into an Input, never guess its effects, and never leave it out.
136
+
134
137
  A candidate *list* for one element comes from the harvest/capture pair above, the same element appearing under more than one selector across the slice, and a known-stable shape in `references/app-profiles.md` — order most specific first (see `references/automation-spec.md`). Check `app-profiles.md` before treating a fresh capture as the only source: a documented shape that is stable across machines is worth ranking beside one this run happened to observe.
135
138
 
136
139
  **Everything you have comes from this session.** There is no cross-session store of selectors to consult and none to write — nothing carries a selector from one task to the next, by design. So derive each target from this run's log, and do not go looking for a remembered profile from an earlier automation.
@@ -143,7 +146,7 @@ If the session folder holds no segments (capture was off → tell the user to en
143
146
 
144
147
  Draft `automation.spec.md` from the Phase 1 task slice + Phase 2 targets — sections, worked example, and the derivation table in `references/automation-spec.md`. Present it inline for confirmation before writing any code; a short markdown spec is easier to review and correct (swap a selector, drop a step, rename an input) than re-deriving it later, and it renders in chat so the user reads the actual steps.
145
148
 
146
- **This is the only user gate in the workflow.** A request that already says to confirm the spec does not answer `## Open questions` the user has not seen: when the spec has any, present them and wait. Everything Phases 1–2 would have stopped to ask comes here instead, collected under `## Open questions` so one review answers all of it:
149
+ **This is the only user gate in the workflow.** A request that already says to confirm the spec does not answer `## Open questions` the user has not seen: when the spec has any, present them and wait. Everything Phases 1–2 would have stopped to ask comes here instead, collected under `## Open questions` so one review answers all of it, never asked on its own before the spec (`AskUser` included) — except which session's log to read (Phase 1), since no spec can be drafted from the wrong session's log:
147
150
 
148
151
  - the requests you sliced, named at the top in the user's own words from each `input` record's `label`, in order — "open notepad" → "type the lyric" → "bold it" — and each partial one in it, with the actions the log is missing; a `turnId` is internal and does not belong in the spec — the user can check their own sentence at a glance, not an id;
149
152
  - each value whose fixed-vs-per-run split you inferred rather than knew;
@@ -197,7 +200,7 @@ Read per-run values from the `input` JObject (`GetRequiredString`/`GetOptionalSt
197
200
 
198
201
  **Log a step marker after every targeted activity** — `Log($"STEP {n} ok: {purpose}")`, numbered to match the spec's `## Steps` rows. Every row gets its own marker, read and verify rows included; a call covering two rows logs both numbers. Never renumber or merge rows. These markers are Phase 6's per-step evidence: profiling records a coded workflow as one activity, so without them no per-step accounting exists (`references/profiling-output.md`).
199
202
 
200
- Element interactions go through the screen handle (`app.Click(...)`), never `uiAutomation.Click(...)`. Write each as a plain deterministic call — no runtime callback into Delegate; if the strict selector and the semantic fallback both fail at run time, the activity throws and the run fails, same as any other UiPath workflow. Each `uiAutomation.Open`/`Attach` returns the screen handle its app's steps need, so a failed open is a hard prerequisite for the rest of the workflow. A multi-app spec gets **one handle per `## Applications` block**, named as that block's Handle (`appExpenses`, `appCrm`), opened up front in declaration order; route every call to the handle for that step's app — a step sent to the wrong window is the failure mode this shape exists to prevent. Set `TargetAppOptions.InteractionMode` explicitly on that `Open`/`Attach` call — the unset default (`HardwareEvents`) is the least reliable option and the most common authoring mistake; reach for `VerifyOptions`, the `Retry<T>` helper in `Main.cs`, and a real `dryRun` gate on irreversible steps per `references/reliability-guide.md`.
203
+ Element interactions go through the screen handle (`app.Click(...)`), never `uiAutomation.Click(...)`. Write each as a plain deterministic call — no runtime callback into Delegate; if the strict selector and the semantic fallback both fail at run time, the activity throws and the run fails, same as any other UiPath workflow. Never wrap an activity in `try`/`catch` to log a warning and carry on: the step's `STEP n ok` marker then claims an action that never happened, and the run reports success on a task it did not do. Each `uiAutomation.Open`/`Attach` returns the screen handle its app's steps need, so a failed open is a hard prerequisite for the rest of the workflow. A multi-app spec gets **one handle per `## Applications` block**, named as that block's Handle (`appExpenses`, `appCrm`), opened up front in declaration order; route every call to the handle for that step's app — a step sent to the wrong window is the failure mode this shape exists to prevent. Set `TargetAppOptions.InteractionMode` explicitly on that `Open`/`Attach` call — the unset default (`HardwareEvents`) is the least reliable option and the most common authoring mistake; reach for `VerifyOptions`, the `Retry<T>` helper in `Main.cs`, and a real `dryRun` gate on irreversible steps per `references/reliability-guide.md`.
201
204
 
202
205
  No entry-point work here — Phase 4 already set the `Main.cs` entry's `input`/`output` to the `Execute` signature. That mirror is the rule on both paths: the runtime binds run arguments to the method's parameters by name, so `input` is `inputJson`/`dryRun`, not the spec's `inputs` keys (those ride inside the `inputJson` payload), and `output` is the one value `Execute` returns (`references/coded-workflow-authoring.md` § project.json). Only on the BlankTemplate fallback is the entry yours to add, for the `.cs` you created.
203
206
 
@@ -217,11 +220,11 @@ Phase 0's build already generated the `.local/.codedworkflows/CodedWorkflow.cs`
217
220
  Run with `dryRun` on and profiling enabled, always `--skip-build` after a successful build, passing the spec's `## Inputs` values as the `inputJson` payload:
218
221
 
219
222
  ```
220
- uip rpa run --file-path "<File>.cs" --project-dir "<ProjectDir>" --skip-build --profiling \
223
+ uip rpa run --timeout 1770 --file-path "<File>.cs" --project-dir "<ProjectDir>" --skip-build --profiling \
221
224
  --input-arguments 'inputJson=@payload.json' --input-arguments dryRun:=true --output json
222
225
  ```
223
226
 
224
- (exact command shapes, payload-file quoting, and stuck-execution recovery in `references/coded-workflow-authoring.md` § uip rpa recipes). Give the shell call a timeout sized to the workflow, about a minute per step, never under 900 s: a run the tool timeout kills has proven only the steps it printed, and the next run starts from the state it left. `dryRun` gates only the irreversible tail (`references/reliability-guide.md` § 4), so everything up to it really runs: a selector that no longer resolves fails here, cheaply.
227
+ (exact command shapes, payload-file quoting, and stuck-execution recovery in `references/coded-workflow-authoring.md` § uip rpa recipes). Give the shell call the tool's maximum timeout, 1800 s, and the CLI `--timeout 1770` (30 s under the shell, or the CLI's own deadline ends a long run first), after `run`: keep `run` right after `rpa`, as the tools that watch for a run match the `uip rpa run` prefix; a run the tool timeout kills has proven only the steps it printed, and the next run starts from the state it left. Run it in the foreground and wait for its result. Never start it as a background command: the turn gets no result to verify, and the run keeps driving the app after the turn moves on. `dryRun` gates only the irreversible tail (`references/reliability-guide.md` § 4), so everything up to it really runs: a selector that no longer resolves fails here, cheaply.
225
228
 
226
229
  **`run`, never `debug start`.** A debug session suspends on an unhandled exception instead of exiting, so the verdict never arrives and a failed run reads as a hang. Use `debug start` only for interactive, human-driven stepping (`references/coded-workflow-authoring.md` § uip rpa recipes).
227
230
 
@@ -2,6 +2,7 @@
2
2
  "description": "Canonical AppAct action -> UiPath activity map. Single source, read during Phase 1 classify and Phase 5 authoring; also the step-action vocabulary for automation.spec.md (Phase 3). Action names track the AppAct discriminated union in src/aria/lib/tools/arguments/ui/UiActions.ts - every literal there needs an entry here. Edit here only; do not restate the table in prose - it drifts.",
3
3
  "handling": {
4
4
  "include": "becomes an activity in the workflow",
5
+ "include-if-changed": "becomes activities only if it changed the page (one per changed element); a read-only run maps to nothing, so drop it",
5
6
  "flag": "surface to the user; port only if trivial",
6
7
  "exclude": "no workflow equivalent by design; drop",
7
8
  "fold": "not its own step; merges into the paired action"
@@ -23,7 +24,7 @@
23
24
  "type_from_credential": { "handling": "include", "activity": "Get Credential + Type Into (secure)", "needsSelector": true, "notes": "reference the Orchestrator asset, never the captured value - see the credential rule in action-activity-map.md" },
24
25
  "wait": { "handling": "include", "activity": "Delay, or Check App State / wait-for-element", "notes": "prefer wait-for-element over fixed Delay" },
25
26
  "drag": { "handling": "flag", "notes": "coordinate drags do not port; a range-selection drag (click start, Shift/Ctrl-click end) maps to two Click activities with a modifier - see coded-workflow-authoring.md § Targeting > Range drag. Any other drag has no proven mapping; port only if trivial" },
26
- "execute_js": { "handling": "flag", "activity": "Invoke JS", "notes": "arbitrary script; port only if trivial" },
27
+ "execute_js": { "handling": "include-if-changed", "activity": "one UI activity per element the script changed: Type Into, Select Item, Check, Click", "needsSelector": true, "notes": "include only a script that changed the page (set a value, checked a box, clicked, dispatched an event); target and fallback per SKILL.md Phase 2, never a semantic-only stand-in. Otherwise drop a script that only read the page (it maps to nothing, and needs no target). A change none of those activities makes (a `form.submit()`, DOM nodes inserted or removed, a storage write, a component API call) is an unresolved step (rung 3) under `## Open questions`, never forced into one." },
27
28
  "print_to_pdf": { "handling": "flag" },
28
29
  "handle_dialog": { "handling": "fold", "notes": "map the paired action, then a follow-up Click on the dialog button if one was pressed" },
29
30
  "crop": { "handling": "exclude", "notes": "vision-only" },
@@ -6,14 +6,14 @@ How to turn a Delegate session's `AppAct` actions into UiPath UIAutomation activ
6
6
 
7
7
  A coded workflow is a deterministic function over its inputs. Include actions that run the same way every time; exclude anything needing judgment.
8
8
 
9
- Per-action classification lives in **`action-activity-map.json`** (same directory) - the single source. Read it; each action carries `handling`: `include` (becomes an activity), `flag` (surface to the user; port only if trivial), `exclude` (no workflow equivalent), `fold` (merges into its paired action).
9
+ Per-action classification lives in **`action-activity-map.json`** (same directory) - the single source. Read it; each action carries `handling`: `include` (becomes an activity), `include-if-changed` (an activity per changed element only if the action changed the page; a read-only run is dropped), `flag` (surface to the user; port only if trivial), `exclude` (no workflow equivalent), `fold` (merges into its paired action).
10
10
 
11
11
  Beyond per-action handling, always exclude:
12
12
  - Judgment or branching on page content ("is this VIP?", "pick the option that fits").
13
13
  - Exploratory reads and screenshots that only informed the agent.
14
14
  - `AskUser`, proven retries (`SKILL.md` Phase 1; any other repeat stays), and dead-end actions that were later undone.
15
15
 
16
- **Parameterize**: values the user typed that vary per run (names, amounts, search terms) become spec `inputs`, not hardcoded literals. Ask the user which typed values are fixed vs per-run.
16
+ **Parameterize**: values the user typed that vary per run (names, amounts, search terms) become spec `inputs`, not hardcoded literals. A fixed-vs-per-run split you inferred goes under the spec's `## Open questions` (`SKILL.md` Phase 3), not a separate question.
17
17
 
18
18
  **Litmus**: writable as a finite function over inputs with no judgment branch → include. Needs reading something ambiguous and deciding → exclude, keep it in the live agent flow.
19
19
 
@@ -29,7 +29,7 @@ Coordinate points never port; never emit a coordinate click. Selectors come pre-
29
29
 
30
30
  - Top-level target: web → the browser URL; desktop → `<wnd app='...' />`. Inner selectors cannot find windows.
31
31
  - Selector attribute priority (most to least reliable): `id` → `name` → `aaname` → `placeholder` → `type` → `class` (avoid `class`).
32
- - If neither a selector nor a usable description resolves, flag the step and ask the user whether to drop it.
32
+ - If neither a selector nor a usable description resolves, mark the step unresolved under the spec's `## Open questions` (`SKILL.md` Phase 2 ladder).
33
33
 
34
34
  ## 4. Credentials
35
35
 
@@ -72,7 +72,7 @@ The confirmed slice carries most of this; the rest is judgment:
72
72
  | Steps: action + order | `step.action` for the turn range, in execution order (segment, then `i`) | which dead-ends to drop; repeats stay unless a proven retry (`SKILL.md` Phase 1) |
73
73
  | Steps: app | `step.app` matched to an application block | which `id` |
74
74
  | Steps: target | `step.target` (`uipathSelector`, `description`) with its `harvest` overlaid on `runId` + `i`; else `noSelector` / `step.targetDescription` | ladder order; whether a shortcut beats the selector |
75
- | Steps: value | `step.value`; `valueRedacted` → an Input | which values are fixed vs `${input}` — **ask the user** |
75
+ | Steps: value | `step.value`; `valueRedacted` → an Input | which values are fixed vs `${input}` — an inferred split goes under `## Open questions` |
76
76
  | Steps: operands | `step.operands` | none — carry every one present through (click type, modifiers, `clearBeforeType`, a drag's destination, `openReason`); a dropped operand is a silently wrong step |
77
77
  | Steps: purpose | `step.purpose` | tightening the wording |
78
78
  | Irreversible | `step.irreversible` — `true` always gates, `false` clears nothing | re-derive from the action (`SKILL.md` Phase 1), since it drives the `dryRun` gate |
@@ -224,7 +224,7 @@ Diagnose by error category, apply the recovery, retry **once** — do not loop t
224
224
  | Error pattern | Cause | Recovery |
225
225
  |---------------|-------|----------|
226
226
  | `connection refused`, `EPIPE`, `pipe not found` | Studio IPC unavailable. Headless: NuGet restore failed or process exited. Desktop: not running. | Re-run — headless relaunches automatically. If persistent, raise `--timeout` and check Helm restore output for NuGet errors. Run `uip rpa studio start` only for Desktop-only verbs or when `UIPATH_RPA_TOOL_USE_STUDIO=1`. |
227
- | `timeout`, `ETIMEDOUT` | Cold Helm NuGet restore (30–90 s) or long operation. | Raise both limits together: shell `timeoutSeconds` toward its documented max, and `uip rpa --timeout <timeoutSeconds − 30> <command>` — the shell timeout must exceed `--timeout` by ≥ 30 s or the shell kills the CLI before it can cancel cleanly. For `validate`, also try `--skip-validation`. |
227
+ | `timeout`, `ETIMEDOUT` | Cold Helm NuGet restore (30–90 s) or long operation. | Raise both limits together: shell `timeoutSeconds` toward its documented max, and `uip rpa <command> --timeout <timeoutSeconds − 30>` (keep the command right after `rpa`; the CLI reads `--timeout` from anywhere in the arguments, and tools that watch a run match the `uip rpa run` prefix) — the shell timeout must exceed `--timeout` by ≥ 30 s or the shell kills the CLI before it can cancel cleanly. For `validate`, also try `--skip-validation`. |
228
228
  | `not authenticated`, `401`, `403` | Auth required for cloud features. | `uip login`, then retry. |
229
229
  | `package not found`, `version not available` | Wrong package ID or version. | Verify via `uip rpa activities find`; omit `version` to auto-resolve latest. |
230
230
  | `project not found`, `no project open` | Wrong `--project-dir` or project not open. | Verify the path points at the `project.json` folder. |
@@ -116,7 +116,7 @@ All on the `app` handle. `target` is a `TargetAnchorableModel` from § Targets.
116
116
  | Wait for state | `bool WaitState(TargetAnchorableModel target, NCheckStateMode checkStateMode, double timeout = 5)`<br>`bool WaitState(TargetAnchorableModel target, CheckStateOptions checkStateOptions)` |
117
117
  | Enabled? | `bool IsEnabled(TargetAnchorableModel target, IsEnabledOptions isEnabledOptions = null)` |
118
118
  | Read attribute | `string GetAttribute(TargetAnchorableModel target, string attribute)`<br>`T GetAttribute<T>(TargetAnchorableModel target, string attribute)` |
119
- | Set value directly | `void SetValue(TargetAnchorableModel target, string value)` |
119
+ | Set value with AI ("Update UI Element") | `void SetValue(TargetAnchorableModel target, string value)` — see below |
120
120
  | Hover | `void Hover(TargetAnchorableModel target, double hoverTime, CursorMotionType cursorMotionType = CursorMotionType.Instant)` |
121
121
  | Scroll | `void MouseScroll(TargetAnchorableModel target, MouseScrollOptions mouseScrollOptions)`<br>`void MouseScroll(TargetAnchorableModel target)` |
122
122
  | Navigate | `void GoToUrl(string url)` |
@@ -128,6 +128,8 @@ All on the `app` handle. `target` is a `TargetAnchorableModel` from § Targets.
128
128
 
129
129
  **`KeyboardShortcut`: use the two pinned overloads above, not the `KeyboardShortcutOptions` one** — that overload rejected the same sequence at run time on 26.10.1.
130
130
 
131
+ **`SetValue` is the AI "Update UI Element" activity, not a direct value write.** It runs in a Chromium browser only and takes only an AI-only target, `Target.FromSemanticSelector(description)`. Any target with a selector, including `Target.WithSemanticSelector(...)`, fails with `Invalid target element for 'Update UI Element' activity. A semantic target is required.` To fill a field, use `TypeInto`. When `TypeInto` fails, fix the `TypeInto` (target, `InteractionMode`); don't swap in `SetValue`.
132
+
131
133
  ### Service-level extras (added in `26.10.3`)
132
134
 
133
135
  ```csharp
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@uipath/delegate-sdk",
3
- "version": "1.204.0-preview.20261016094708",
3
+ "version": "1.204.0-preview.20261019134103",
4
4
  "description": "UiPath Delegate SDK - Programmatic agent interface",
5
5
  "license": "Apache-2.0",
6
6
  "type": "commonjs",
@@ -50,10 +50,10 @@
50
50
  "zod-to-json-schema": "^3.25.1"
51
51
  },
52
52
  "optionalDependencies": {
53
- "@uipath/delegate-runtime-darwin-arm64": "1.204.0-preview.20261016094708",
54
- "@uipath/delegate-runtime-win32-x64": "1.204.0-preview.20261016094708",
55
- "@uipath/delegate-runtime-win32-x64-driver": "1.204.0-preview.20261016094708",
56
- "@uipath/delegate-runtime-linux-x64": "1.204.0-preview.20261016094708"
53
+ "@uipath/delegate-runtime-darwin-arm64": "1.204.0-preview.20261019134103",
54
+ "@uipath/delegate-runtime-win32-x64": "1.204.0-preview.20261019134103",
55
+ "@uipath/delegate-runtime-win32-x64-driver": "1.204.0-preview.20261019134103",
56
+ "@uipath/delegate-runtime-linux-x64": "1.204.0-preview.20261019134103"
57
57
  },
58
58
  "devDependencies": {
59
59
  "@types/node": "^22.0.0",