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

package/skills/uipath-maestro-case/references/plugins/variables/global-vars/planning.md

@@ -28,14 +28,14 @@ The Category column is REQUIRED in the SDD template.
 
 1. Read the Case Variables table rows.
 2. For EACH row, present a single AskUserQuestion: `<rowName>`: `In` / `Out` / `Variable` / `Skip — not a variable`. Multi-select if the harness allows batching; otherwise one prompt per row.
-3. Record the user's answer in memory and emit the T-entries as if the Category column had been authored that way.
+3. Record the user's answer in memory and emit the rows as if the Category column had been authored that way.
 4. Strongly recommend (via plain-text output before/after the prompts) that the user migrate their SDD to include the column for future regenerate-from-scratch runs.
 
 Never default missing categories to a guess. The pre-α "Listed in Trigger Initial Variable Mapping → In argument" inference rule is removed under α and MUST NOT be re-implemented as a fallback. The post-α table shape is defined by the case SDD template (authored by `uipath-planner`); canonical Category semantics live in [impl-json.md](impl-json.md).
 
 ## Phase 2 Structural Validation
 
-Validate at planning time (before tasks.md is finalized). All checks operate on SDD content alone — no spec data needed yet.
+Validate at resolution time (before Phase 2 begins). All checks operate on SDD content alone — no spec data needed yet.
 
 | Check | Severity | Action |
 |---|---|---|
@@ -45,30 +45,32 @@ Validate at planning time (before tasks.md is finalized). All checks operate on
 | `Category=Variable` row has `sourceTriggers` but no matching `sourceFields` entry per trigger | ERROR | Reject — multi-trigger requires per-trigger sourceField. |
 | `Category=In` row has CSV `sourceTriggers` (more than one T-number) | ERROR | Reject — an In-arg binds to exactly one trigger; CSV is the multi-trigger `Variable` form. |
 | `Category=In` row has non-empty `sourceFields` | ERROR | Reject — In-args select a trigger but extract no payload field; use `Category=Variable` for extraction. |
-| `sourceTriggers` references a T-number that doesn't exist in tasks.md (any category) | ERROR | Reject — orphan reference. |
+| `sourceTriggers` references a trigger that doesn't exist in the SDD (any category) | ERROR | Reject — orphan reference. |
 
 Phase 3 (implementation) catches spec-dependent issues — see [`impl-json.md`](impl-json.md) § Phase 3 Validation.
 
-## tasks.md Entry Format
+## Fields to Resolve
 
-One T-entry per Case Variables row. Place after the case file (T01) and all trigger T-entries (T02+), before stages. T-number for the first variable depends on trigger count.
+Case variables have no registry lookup, so they produce **no `tasks/registry-resolved.json` entry**. These are reasoning fields only — Phase 2 reads them from `sdd.md` ([planning.md § Step 4](../../../planning.md)).
 
-```markdown
-## T05: Declare In-argument "applicantName"
+One caseplan variable per Case Variables row. Place after the case file (T01) and all trigger rows (T02+), before stages. T-number for the first variable depends on trigger count.
+
+```text
+In-argument "applicantName"
 - category: In
 - type: string
 - sourceTriggers: T03            # single T-number; omit to bind the primary trigger (T02)
 - default: ""
 - verify: inputs[] formal slot + inputOutputs[] companion (elementId = id-map[T03].id) + that trigger node's outputs[] bridge written.
 
-## T06: Declare Variable "subject"
+Variable "subject"
 - category: Variable
 - type: string
 - sourceTrigger: T02
 - sourceField: response.subject
 - verify: inputOutputs[] entry (id=subject, elementId="root"); trigger T02's outputs[] carries Pattern C wire (source="=response.subject", var=id="subject"); no inputs[] entry.
 
-## T07: Declare Variable "caseStarter"
+Variable "caseStarter"
 - category: Variable
 - type: string
 - sourceTriggers: T02, T03
@@ -77,29 +79,29 @@ One T-entry per Case Variables row. Place after the case file (T01) and all trig
     T03: response.initiator
 - verify: one inputOutputs[] companion (elementId="root") shared across triggers; each listed trigger's outputs[] has its own Pattern C wire targeting the companion.
 
-## T08: Declare Variable "caseStatus"
+Variable "caseStatus"
 - category: Variable
 - type: string
 - default: "Open"
 - verify: inputOutputs[] entry (id=caseStatus, elementId="root", default="Open"); no trigger output entries.
 
-## T09: Declare Out-argument "finalDecision"
+Out-argument "finalDecision"
 - category: Out
 - type: string
-- producedBy: T15.outputs.finalDecision   # informational reference to the producing task T-entry
+- producedBy: T15.outputs.finalDecision   # informational reference to the producing task
 - verify: outputs[] formal entry (var=finalDecision); companion in inputOutputs[] ALWAYS emitted (with default="" when Default empty); io-binding validator confirms producer task output has id=finalDecision.
 ```
 
-**Field semantics on the T-entry:**
+**Field semantics:**
 
 - `category` — required, one of `In`, `Out`, `Variable`
-- `type` — required, one of `string`, `integer`, `float`, `double`, `boolean`, `datetime`, `date`, `jsonSchema`, `file`
+- `type` — required, one of `string`, `number`, `integer`, `float`, `double`, `boolean`, `datetime`, `date`, `jsonSchema`, `file`. **Emit the SDD's declared type verbatim — never substitute a near-equivalent.** `number` and `integer` are distinct and both valid; rewriting an SDD `number` as `integer` (or `float`/`double` as `number`) produces a caseplan that validates but no longer matches the declared contract, and downstream extract rows inherit the wrong type. If the SDD names a type not listed here, keep it as written and record it as a Review Flag rather than mapping it onto the nearest listed value.
 - `sourceTrigger` — T-number when the value comes from a single trigger's payload (Variable category)
 - `sourceTriggers` — for a `Variable`: CSV of T-numbers when multiple triggers populate it. For an `In`-arg: a single `T<N>` selecting the trigger it binds to (blank → primary trigger T02; never a CSV). Replaces the legacy `triggerRef` field.
 - `sourceFields` — per-trigger payload paths (Variable only). Single-trigger form is `<path>`; multi-trigger form is a YAML-style sub-block with one `T<N>: <path>` per line. Empty on `In` rows.
 - `default` — initial value, **always written as a quoted string, for every `type`**. Drives the `default` field on the companion `inputOutputs[]` entry. This is the one field where **string-encoding overrides losslessness**: an SDD Default cell holding a bare JSON object, number, or boolean is re-encoded here rather than copied verbatim, because the downstream field is string-typed and a non-primitive value is silently deleted at BPMN serialization (see [`impl-json.md` § `default` encoding](impl-json.md#default-encoding-every-type-mandatory)). Record the re-encoding — it is the only Rule 6 exception in this plugin.
 
-  | SDD Default cell | `tasks.md` `default:` |
+  | SDD Default cell | caseplan variable `default` |
   |---|---|
   | `{"amount":125.5}` | `"{\"amount\":125.5}"` |
   | `5` | `"5"` |
@@ -117,7 +119,9 @@ One T-entry per Case Variables row. Place after the case file (T01) and all trig
 
 ## Types
 
-`"string"` | `"integer"` | `"float"` | `"double"` | `"boolean"` | `"datetime"` | `"date"` | `"jsonSchema"` | `"file"`
+`"string"` | `"number"` | `"integer"` | `"float"` | `"double"` | `"boolean"` | `"datetime"` | `"date"` | `"jsonSchema"` | `"file"`
+
+This list is not a normalisation target. Carry the SDD's type across unchanged; `number` -> `integer` is the substitution that has actually shipped and it silently breaks the extract rows typed from that variable.
 
 ## Naming
 
@@ -125,6 +129,6 @@ camelCase IDs (`=vars.claimId`). See [`impl-json.md`](impl-json.md) § Uniquenes
 
 ## Completeness obligation
 
-Per [planning.md §4.0](../../../planning.md), every row in the Case Variables table emits exactly one T-entry. Skipping rows because their Category cannot be determined is forbidden — invoke AskUserQuestion instead. The pre-approval cross-check counts variable-table rows against emitted variable T-entries; mismatch is a defect.
+Per the completeness principle in [implementation.md](../../../implementation.md), every row in the Case Variables table emits exactly one caseplan variable. Skipping rows because their Category cannot be determined is forbidden — invoke AskUserQuestion instead. The pre-approval cross-check counts variable-table rows against emitted variable elements; mismatch is a defect.
 
 <!-- END: planning.md -->

package/skills/uipath-maestro-case/references/plugins/variables/io-binding/impl-json.md

@@ -32,7 +32,7 @@ Output IDs are name-based camelCase per [uniqueness rule](../global-vars/impl-js
 
 ## Output Binding Shapes
 
-Each task plugin emits `data.outputs[]` entries by combining its Step 0 schema (from `tasks describe` for non-connector plugins, `case spec --input-details` `caseShape.outputs[]` for connector plugins) with the SDD's `->` / `=` rows and any bare items added to `tasks.md` by schema discovery. Bare is an internal auto-mint form, never an SDD Outputs operator. Apply these rules during the plugin's task-write step.
+Each task plugin emits `data.outputs[]` entries by combining its Step 0 schema (from `tasks describe` for non-connector plugins, `case spec --input-details` `caseShape.outputs[]` for connector plugins) with the SDD's `->` / `=` rows and any bare items added by schema discovery. Bare is an internal auto-mint form, never an SDD Outputs operator. Apply these rules during the plugin's task-write step.
 
 Resolve the schema descriptor for every SDD field path **before** choosing an output shape:
 
@@ -40,18 +40,26 @@ Resolve the schema descriptor for every SDD field path **before** choosing an ou
 2. With no remaining segments, the resolved descriptor is that top-level output.
 3. With remaining segments, walk them exactly through the top-level output's `Body.Properties` (`body.properties` in normalized case-shape data; `JsonSchema.Properties` is the equivalent CLI mirror). The descriptor after the final segment is the **leaf descriptor**.
 4. For a nested path, set the emitted `name` to the leaf's display name when present, otherwise its exact final path segment. Take `type` plus any type-refining attributes from the leaf descriptor only. Never copy the parent object's `jsonSchema` type or body onto a scalar leaf.
-5. A nested path references its top-level parent. Do not additionally auto-mint that parent unless tasks.md contains a separate schema-discovered bare item for it. If any segment does not resolve, log `ERROR` and skip the binding; never fall back to the last resolved parent.
+5. A nested path references its top-level parent. Do not additionally auto-mint that parent unless the projected output list contains a separate schema-discovered bare item for it. If any segment does not resolve, log `ERROR` and skip the binding; never fall back to the last resolved parent.
 
-For each top-level Step 0 entry, check whether tasks.md references it either as a bare name or as the first segment of an explicit `->` path. Only entries with no such reference fall back to schema-driven auto-minting.
+For each top-level Step 0 entry, check whether the SDD references it either as a bare name or as the first segment of an explicit `->` path. Only entries with no such reference fall back to schema-driven auto-minting.
 
 - **`<sdd-field-path> -> <sdd-name>`** (extract) → reassign-shape. Let `baseId = camelCase(leaf segment)` and allocate `id` per the global [uniqueness rule](../global-vars/impl-json.md#uniqueness-rule), including its controlled equal-name alias. Emit `{name: <resolved name>, type: <resolved descriptor's type>, id: <allocated id>, var: "<sdd-name>", originalVar: <allocated id>, value: "<sdd-name>", source: "=<sdd-field-path>", target: "=<allocated id>", elementId: "<stage-task>"}`. `<resolved name>` is the top-level schema display name for a top-level path; for a nested path it is the leaf display name when present, otherwise the exact final path segment. **`source` is the SDD's left-side string with `=` prefix, verbatim.** **`type` is required on every emitted output — FE rejects entries without it.** **`originalVar` is load-bearing and mirrors the allocated `id`** — it records the output slot before reassignment and tells FE's `mutateRootVariables` (`VariableMutationUtils.ts:135`) to skip root-mirroring, preserving the case-Variable companion across FE edits. Example: if another task already owns `id: "aPIOutput1"`, `APIOutput1 -> renamedResult` emits `id: "aPIOutput12"`, `target: "=aPIOutput12"`, `var: "renamedResult"`, and `originalVar: "aPIOutput12"`.
 - **Bare `<name>`** (no operator) → auto-mint shape: `{name, type: <Step 0 entry's type>, id: <camelCase(name)>, var: <id>, value: <id>, source: <Step 0 entry's source verbatim>, target: "=<id>", elementId}`. No `originalVar`. Used for top-level Step 0 entries the SDD doesn't alias.
-- **`<sdd-name> = <expression>`** (set / compute / copy) → Scenario E shape: `{name: "<sdd-name>", custom: true, var: "<sdd-name>", value: "<expression>", source: "<same as value>", target: "", body: "", type: <case var's type>, elementId: "root"}`. **No `id`**, no `originalVar`. NO root mirror — FE's `isUpdateExistingOutput` filter at `VariableMutationUtils.ts:49-64` skips it. Canonicalize `=metadata.X` to `=js:metadata.X` in both `value` and `source`; retain the SDD-natural form in `tasks.md`. For a quoted string literal, treat the quotes as SDD delimiters: `status = "InReview"` emits JSON `"value": "InReview", "source": "InReview"` — never embed the delimiters as payload (`"value": "\"InReview\""`).
+- **`<sdd-name> = <expression>`** (set / compute / copy) → Scenario E shape: `{name: "<sdd-name>", custom: true, var: "<sdd-name>", value: "<expression>", source: "<same as value>", target: "", body: "", type: <case var's type>, elementId: "root"}`. **No `id`**, no `originalVar`. **On this shape only, `target` and `body` are present-but-blank: emit `"target": ""` and `"body": ""` literally rather than dropping the keys.** An omitted key is not the same as a blank one — the FE reads a missing `target` as unset rather than deliberately-empty. Blank values belong to Scenario E and nowhere else:
+
+| shape | `target` | `value` | `body` |
+|---|---|---|---|
+| Scenario E (`=` custom) | `""` | the expression | `""` |
+| reassign (`->`) | `"=<allocated id>"` | the SDD name | absent |
+| bare auto-mint | `"=<id>"` | the `id` | absent |
+
+Never blank a `target` or `value` on a reassign or auto-mint row to satisfy the rule above — those carry real values, and emptying them is a different defect. NO root mirror — FE's `isUpdateExistingOutput` filter at `VariableMutationUtils.ts:49-64` skips it. Canonicalize `=metadata.X` to `=js:metadata.X` in both `value` and `source`; retain the SDD-natural form in the projected item. For a quoted string literal, treat the quotes as SDD delimiters: `status = "InReview"` emits JSON `"value": "InReview", "source": "InReview"` — never embed the delimiters as payload (`"value": "\"InReview\""`).
 - **Schema fields with no SDD reference** → fall back to auto-mint shape (`var` = camelCased schema name). Connector plugins additionally apply the [uniqueness rule](../global-vars/impl-json.md#uniqueness-rule) dedup-suffix on collision (e.g., `response` → `response2`).
 
 **Equal-name extract dispatch.** Dispatch by the explicit operator before comparing names; equal operands select the reassign shape, never the bare auto-mint branch. Apply the global [controlled-alias rule](../global-vars/impl-json.md#uniqueness-rule). With no unrelated collision, `greeting -> greeting` emits `id`, `var`, `originalVar`, and `value` as `"greeting"`, with `source: "=greeting"` and `target: "=greeting"`. `originalVar` distinguishes reassignment from a bare output and keeps the predeclared root companion intact during frontend synchronization; the linked allocator owns any required suffixing.
 
-**Nested extract example.** Given a top-level `Error` output with `type: "jsonSchema"` and `Body.Properties.Message.Type: "string"`, the SDD row `Error.Message -> errorMessage` emits only this reassigned leaf unless schema discovery separately adds a bare `Error` item to `tasks.md`:
+**Nested extract example.** Given a top-level `Error` output with `type: "jsonSchema"` and `Body.Properties.Message.Type: "string"`, the SDD row `Error.Message -> errorMessage` emits only this reassigned leaf unless schema discovery separately adds a bare `Error` item:
 
 ```json
 {
@@ -113,9 +121,9 @@ resolve_output_reference_id(caseplan, src_output):
 
 Normal, bare, and reassigned outputs use their own `.id`. This is load-bearing when reassignment collision handling produces `id: "estimatedAge2"` with `var: "estimatedAge"`: downstream references must use `=vars.estimatedAge2`. Only a custom `=` output intentionally lacks `.id`; its `.var` points to an existing Case-variable companion, so resolve through that companion's verified `.id`. Never use a reassigned output's `.var` as its source reference ID.
 
-For each task input in `tasks.md`:
+For each task input row in the SDD's Inputs table:
 
-**Literals/expressions** — write the value string directly to `input.value`. Values shown are POST-rewrite — impl translates `=metadata.X` from `tasks.md` to `=js:metadata.X` per the [canonical-form table](../../../bindings-and-expressions.md#canonical-form-per-sink) (plain `=metadata.X` is not resolved by the lookup-path evaluator). **A quoted string literal's quotes are SDD delimiters, never payload** — same rule as the `=` output side above: `tasks.md`'s `APIInput1 = "literal-seed"` emits `"value": "literal-seed"`, NOT `"value": "\"literal-seed\""`. `tasks.md` keeps the SDD cell's own quotes ([planning.md § code spans](planning.md)); `caseplan.json` strips them. Embedded delimiters pass `validate` and ship the quote characters to the resource as payload:
+**Literals/expressions** — write the value string directly to `input.value`. Values shown are POST-rewrite — impl translates the SDD's `=metadata.X` to `=js:metadata.X` per the [canonical-form table](../../../bindings-and-expressions.md#canonical-form-per-sink) (plain `=metadata.X` is not resolved by the lookup-path evaluator). **A quoted string literal's quotes are SDD delimiters, never payload** — same rule as the `=` output side above: the SDD's `APIInput1 = "literal-seed"` emits `"value": "literal-seed"`, NOT `"value": "\"literal-seed\""`. The projected item keeps the SDD cell's own quotes ([planning.md § code spans](planning.md)); `caseplan.json` strips them. Embedded delimiters pass `validate` and ship the quote characters to the resource as payload:
 ```
 "=vars.amount"  |  "=js:metadata.ExternalId"  |  "literal-seed"  |  "50"  |  "=js:new Date()"
 ```
@@ -199,7 +207,7 @@ If none of these exist → **pure orphan**, prompt the author.
 | Producer status | Validate time action |
 |---|---|
 | Companion has non-empty `default` | OK — Out-arg always has a value. |
-| At least one producer (extraction, assignment, or bare-name) exists in tasks.md AND its task is resolved (not Rule 17 placeholder) | OK — producer wires the slot when its task fires. |
+| At least one producer (extraction, assignment, or bare-name) exists in the SDD AND its task is resolved (not Rule 17 placeholder) | OK — producer wires the slot when its task fires. |
 | Producer declared but its task is a Rule 17 placeholder (declared-but-unwirable) | **Silent WARN.** Log to `tasks/build-issues.md` under `## Open Items for User`. Rule 17 already prompted the author for this task. |
 | NO producer anywhere AND companion default empty | **AskUserQuestion** — pure orphan. 4 options below. |
 
@@ -211,13 +219,13 @@ for entry in root.outputs[]:
   case_var_row = tasks_md_row_for_out_arg(name=entry.name)
   has_companion_default = (case_var_row.default not empty)
 
-  # Producer scan — three patterns. All operate on tasks.md `outputs:` lines:
-  has_extraction_producer  = exists in tasks.md any task's T-entry with an `outputs:` line containing `<field> -> <var>` (where var matches the Out-arg's var)
-  has_assignment_producer  = exists in tasks.md any task's T-entry with an `outputs:` line containing `<var> = <expression>` (where var matches the Out-arg's var)
-  has_bare_name_producer   = exists in tasks.md any task's T-entry with an `outputs:` line `- <name>` (bare, no operator) where camelCase(name) == var
+  # Producer scan — three patterns. All operate on the SDD Outputs rows projected per planning.md:
+  has_extraction_producer  = exists in the SDD any task with an Outputs row projecting to `<field> -> <var>` (where var matches the Out-arg's var)
+  has_assignment_producer  = exists in the SDD any task with an Outputs row projecting to `<var> = <expression>` (where var matches the Out-arg's var)
+  has_bare_name_producer   = exists a schema-discovered bare output `<name>` (no operator) where camelCase(name) == var
   has_any_producer         = has_extraction_producer || has_assignment_producer || has_bare_name_producer
 
-  producer_task_unresolved = the tasks.md-declared producer task is a Rule 17 placeholder (look up the task in caseplan.json by displayName; check `node.data.inputs` is empty `{}`)
+  producer_task_unresolved = the SDD-declared producer task is a Rule 17 placeholder (look up the task in caseplan.json by displayName; check `node.data.inputs` is empty `{}`)
 
   if has_companion_default:
       # Companion default guarantees a value; producer is optional bonus
@@ -236,10 +244,10 @@ for entry in root.outputs[]:
 Out-argument "<name>" (id v<random8>, var <var>) has no value source:
   SDD row Default: <"" (empty)>
   Companion root.inputOutputs[].id="<var>": exists, default=""
-  Producing task in tasks.md (extraction or assignment): none found
+  Producing task in the SDD (extraction or assignment): none found
 
 Pick one:
-  (a) Add producer task output — supply the producer task's **display name** as shown in tasks.md (e.g., `Send Slack Message`). If the named task doesn't exist, re-prompt. Skill appends `<field> -> <var>` to that task's Outputs.
+  (a) Add producer task output — supply the producer task's **display name** as shown in the SDD (e.g., `Send Slack Message`). If the named task doesn't exist, re-prompt. Skill appends `<field> -> <var>` to that task's Outputs.
   (b) Add a Default value to the SDD Case Variables row — supply value inline (literal string).
   (c) Recategorize as Variable (case-internal state) or remove the variable.
   (d) Continue with best-effort emit (case builds; runtime returns empty string for this Out-arg; entry logged under "Open Items for User" in build-issues.md).
@@ -247,9 +255,9 @@ Pick one:
 
 **Skill response per user pick:**
 
-- **(a)** Edit `tasks.md`: append `<field> -> <var-name>` as a new `outputs:` list item on the named task's T-entry (use the spec-derived field name if available, else an `<UNKNOWN>` placeholder). Re-run the Phase 1 dispatcher from the modified tasks.md, then retry Step 12.
-- **(b)** Edit `tasks.md`: set `default: "<value>"` on the Out-arg's T-entry. Re-run Phase 1 dispatcher, then retry Step 12.
-- **(c)** Prompt the user inline: `Recategorize as "Variable" or "Remove" the variable?` On `Variable`: edit `tasks.md` Case Variables row Category → Variable, re-run Phase 1 dispatcher, retry Step 12. On `Remove`: delete the row from `tasks.md`, re-run Phase 1 dispatcher, retry Step 12.
+- **(a)** Edit `sdd.md`: append a `<field> -> <var-name>` row to the named task's Outputs table (use the spec-derived field name if available, else an `<UNKNOWN>` placeholder). Re-run Phase 1 from the modified `sdd.md`, then retry Step 12.
+- **(b)** Edit `sdd.md`: set the Out-arg's `Default` cell in the Case Variables table. Re-run Phase 1, then retry Step 12.
+- **(c)** Prompt the user inline: `Recategorize as "Variable" or "Remove" the variable?` On `Variable`: edit the SDD's Case Variables row Category → Variable, re-run Phase 1 dispatcher, retry Step 12. On `Remove`: delete the row from `sdd.md`, re-run Phase 1, retry Step 12.
 - **(d)** Append the build-issues entry (template below) and continue to Phase 4. No re-run.
 
 Option (d) is the build-with-best escape for cases where the author intends to wire the producer later but wants to keep iterating now — equivalent to the silent-WARN treatment that declared-but-unresolvable producers (T20-style) get automatically.
@@ -274,7 +282,7 @@ See [implementation.md § Step 12 — End-of-Phase-3 validator pass](../../../im
 
 **Input consumers.** Where a `=vars.X` reference resolves to a declaration with a different `type` than the consuming input expects, log WARNING. Proceed (string coercion is common and runtime-tolerant).
 
-**Extract outputs.** For every `->` row, re-resolve its full source path against the Step 0 schema using the algorithm above. Require the emitted output's `name` and `type` to equal the resolved name and leaf type. For a nested path, also require that the top-level parent was not separately auto-minted unless tasks.md contains a schema-discovered bare item for it. A mismatch is `ERROR`: correct the output from the resolved descriptor and re-run this check before Phase 4. Do not accept a passing `uip maestro case validate` as evidence here; structural validation does not compare a nested binding with its schema leaf.
+**Extract outputs.** For every `->` row, re-resolve its full source path against the Step 0 schema using the algorithm above. Require the emitted output's `name` and `type` to equal the resolved name and leaf type. For a nested path, also require that the top-level parent was not separately auto-minted unless there is a schema-discovered bare item for it. A mismatch is `ERROR`: correct the output from the resolved descriptor and re-run this check before Phase 4. Do not accept a passing `uip maestro case validate` as evidence here; structural validation does not compare a nested binding with its schema leaf.
 
 ### Check 4 — No surviving `$xref` markers
 
@@ -363,7 +371,7 @@ Pick one:
 
 **Skill response per pick:**
 
-- Unbound (a) — write the Inputs row to `tasks.md` + `caseplan.json`, run the Step 9.8 binding for that input, retry Check 5. (b) — set the input `value` to a placeholder and append a `high` review item (`rev_unbound_input_<task>_<field>`), continue. (c) — append the build-issues entry, continue. No re-run.
+- Unbound (a) — write the Inputs row to `sdd.md` + `caseplan.json`, run the Step 9.8 binding for that input, retry Check 5. (b) — set the input `value` to a placeholder and append a `high` review item (`rev_unbound_input_<task>_<field>`), continue. (c) — append the build-issues entry, continue. No re-run.
 - Phantom (a) — rewrite the output `source`/`Field` in `caseplan.json`, retry Check 5. (b) — delete the output row (and any now-orphaned `=vars.<caseVar>` consumer falls to Check 1). (c) — append the build-issues entry, continue.
 
 Check 5 honors the same **build-with-best** policy as Checks 1, 2, 4: option (c) appends a `## Open Items for User` entry and proceeds to Phase 4. Phase 4 `validate` stays green (a missing input / phantom extract is structurally valid); the runtime concern is surfaced for pre-publish review.
@@ -379,7 +387,7 @@ Check 5 honors the same **build-with-best** policy as Checks 1, 2, 4: option (c)
 
 ## Connector Tasks
 
-Connector task input values are written during Step 9.7 (connector detail), not during this I/O binding step. Resolve cross-task output reference IDs with the authoritative algorithm above before constructing the `input-values` body from `tasks.md`, then apply the canonical wrap per sink:
+Connector task input values are written during Step 9.7 (connector detail), not during this I/O binding step. Resolve cross-task output reference IDs with the authoritative algorithm above before constructing the `input-values` body from the resolved entry, then apply the canonical wrap per sink:
 
 ```json
 { "body": { "email": "=js:(vars.employeeEmail)", "caseRef": "=js:(metadata.ExternalId)" } }

package/skills/uipath-maestro-case/references/plugins/variables/io-binding/planning.md

@@ -1,12 +1,14 @@
 # I/O Binding — Planning
 
-Trust the SDD. Emit inputs/outputs exactly as declared. Every SDD Outputs row carries `->` or `=`; preserve that operator and both operands through `tasks.md`. Bare `tasks.md` outputs come only from resolved-schema discovery, never from an SDD row. There is no `caseplan.json` yet — all validation happens during [implementation](impl-json.md).
+Trust the SDD. Emit inputs/outputs exactly as declared. Every SDD Outputs row carries `->` or `=`; preserve that operator and both operands into the caseplan. Bare outputs come only from resolved-schema discovery, never from an SDD row.
 
-## SDD Outputs table to `tasks.md` projection (mandatory)
+The **canonical binding form** below (`<field-path> -> <case-variable>`, `<case-variable> = <expression>`, `<Field> <- <Binding>`) is the normalized reading of an SDD table row that [impl-json.md](impl-json.md) consumes when it writes `data.inputs[]` / `data.outputs[]`. It is a reasoning form, not a file: never write it to disk as an intermediate plan.
 
-The SDD Outputs table has separate `Field`, `Type`, and `Binding / Value` columns, while `tasks.md` uses one canonical list item per row. Project each SDD row exactly once:
+## SDD Outputs table to caseplan projection (mandatory)
 
-| SDD `Field` | SDD `Binding / Value` | Canonical `tasks.md` item |
+The SDD Outputs table has separate `Field`, `Type`, and `Binding / Value` columns; the canonical form is one item per row. Project each SDD row exactly once:
+
+| SDD `Field` | SDD `Binding / Value` | Canonical item |
 |---|---|---|
 | `Error.Message` | `-> errorMessage` | `Error.Message -> errorMessage` |
 | `—` or blank | `literalResult = "literal-assigned"` | `literalResult = "literal-assigned"` |
@@ -25,13 +27,13 @@ Treat `—` and blank `Field` cells on `=` rows as presentation-only placeholder
 - literalResult = "literal-assigned"
 ```
 
-Before the Phase 1 approval gate, reject any SDD Outputs row without `->` or `=`, and reject any `tasks.md` output item whose first token is `—`, `->`, or `=`. Every SDD-projected item must match `<field-path> -> <case-variable>` or `<case-variable> = <expression>`; `<top-level-field>` is reserved for schema-discovered items.
+Before writing the task's `data.outputs[]`, reject any SDD Outputs row without `->` or `=`, and reject any projected output item whose first token is `—`, `->`, or `=`. Every SDD-projected item must match `<field-path> -> <case-variable>` or `<case-variable> = <expression>`; `<top-level-field>` is reserved for schema-discovered items.
 
-## SDD Inputs table to `tasks.md` projection (mandatory)
+## SDD Inputs table to caseplan projection (mandatory)
 
-The SDD Inputs table has separate `Field`, `Type`, and `Binding` columns, exactly like the Outputs table above — but the `tasks.md` input item drops the `Type` column entirely. Project each SDD Inputs row to `<Field> <- <Binding>` or `<Field> = <Binding>` (operator comes from the Binding cell itself, per [Input/Output Notation](#inputoutput-notation) below); never carry the `Type` column into `tasks.md`:
+The SDD Inputs table has separate `Field`, `Type`, and `Binding` columns, exactly like the Outputs table above — but the canonical input item drops the `Type` column entirely. Project each SDD Inputs row to `<Field> <- <Binding>` or `<Field> = <Binding>` (operator comes from the Binding cell itself, per [Input/Output Notation](#inputoutput-notation) below); never carry the `Type` column through to the caseplan:
 
-| SDD `Field` | SDD `Type` | SDD `Binding` | Canonical `tasks.md` item |
+| SDD `Field` | SDD `Type` | SDD `Binding` | Canonical item |
 |---|---|---|---|
 | `APIInput1` | `string` | `"literal-seed"` | `APIInput1 = "literal-seed"` |
 | `APIInput1` | `string` | `=vars.caseInput` | `APIInput1 = =vars.caseInput` |
@@ -53,7 +55,7 @@ The SDD Inputs table has separate `Field`, `Type`, and `Binding` columns, exactl
 - APIInput1 <- "Binding Matrix"."Echo literal".APIOutput1
 ```
 
-Before the Phase 1 approval gate, reject any `tasks.md` input item that wraps its value in backticks or in a quote pair the SDD `Binding` cell did not itself contain, and any item whose name and value are separated by `:` rather than `<-` or `=`.
+Before writing the task's `data.inputs[]`, reject any projected input item that wraps its value in backticks or in a quote pair the SDD `Binding` cell did not itself contain, and any item whose name and value are separated by `:` rather than `<-` or `=`. The same delimiter-strip rule governs the value that reaches `input.value` in `caseplan.json`: a backtick or quote the SDD cell did not contain must never survive into the JSON.
 
 ## Discovering Input/Output Names
 
@@ -72,9 +74,9 @@ Before the Phase 1 approval gate, reject any `tasks.md` input item that wraps it
 
    `<sdd-field-path> -> <case variable>`. Left side is the full runtime path. Right side becomes `var` / `value` on `task.data.outputs[]` (the case-scope variable pointer); `id` / `originalVar` / `target` are allocated independently from the source leaf and global collision pool. Extracted source is `"=<sdd-field-path>"` verbatim — the skill emits the SDD's left-side string with `=` prefix; never adds, removes, or infers envelope prefixes. Target case variable MUST exist in the Case Variables table.
 
-   **Equal-name extract is still an extract.** `greeting -> greeting` means "write schema field `greeting` into the already-declared case variable `greeting`." Keep the arrow in `tasks.md`; never normalize it to bare `greeting`. Implementation keeps `var` / `value` pointed at the existing `greeting` Case variable and always emits `originalVar`. The source-side `id`, `originalVar`, and `target` stay `greeting` when the only collision is that matching root companion; an unrelated task/trigger/rule owner forces normal allocation (`greeting2`, `greeting3`, ...).
+   **Equal-name extract is still an extract.** `greeting -> greeting` means "write schema field `greeting` into the already-declared case variable `greeting`." Keep the arrow in the projected item; never normalize it to bare `greeting`. Implementation keeps `var` / `value` pointed at the existing `greeting` Case variable and always emits `originalVar`. The source-side `id`, `originalVar`, and `target` stay `greeting` when the only collision is that matching root companion; an unrelated task/trigger/rule owner forces normal allocation (`greeting2`, `greeting3`, ...).
 
-   **`=` operator — set / compute / copy a literal or expression into an existing case variable.** Left side is the target case variable (must already exist in Case Variables); right side is the expression. The SDD `Field` cell is `—` or blank and contributes no token to `tasks.md`:
+   **`=` operator — set / compute / copy a literal or expression into an existing case variable.** Left side is the target case variable (must already exist in Case Variables); right side is the expression. The SDD `Field` cell is `—` or blank and contributes no token to the projected item:
    ```markdown
    - outputs:
      - caseStatus  = "InReview"                            # literal
@@ -82,9 +84,9 @@ Before the Phase 1 approval gate, reject any `tasks.md` input item that wraps it
      - summary     = =vars.response.message.text           # copy from another variable's sub-field
    ```
 
-   `<case variable> = <expression>`. Expression can be a plain literal string/number/bool, a `=js:` computation, or a `=vars.X.Y` variable reference. Target case variable MUST exist in the Case Variables table.
+   `<case variable> = <expression>`. Expression can be a plain literal string/number/bool, a `=js:` computation, or a `=vars.X.Y` variable reference. Target case variable MUST exist in the Case Variables table. **For `=` rows only, the emitted JSON carries `"target": ""` and `"body": ""` as present keys** — an empty value is not a reason to omit the key. This blank form is specific to `=`; `->` and bare outputs carry a real `target` (`"=<id>"`) and a real `value`, and must not be blanked. Full shape: [`impl-json.md` § Scenario E](impl-json.md).
 
-   **Dot-path support** on the left side of `->`: full paths like `response.message.ts`, `response.data.user.email`, `Error.code` are emitted as-is. The first segment selects the top-level schema output; implementation then walks that output's nested schema one segment at a time and takes the emitted `type` from the final leaf — never from the top-level parent. A nested row references its top-level parent, so `Error.Message -> errorMessage` does NOT also auto-mint a bare `Error` output unless schema discovery independently adds `Error` to `tasks.md`. Array indexing (`items[0]`) is NOT supported in v1 — fall back to consuming the array variable and using `=js:` expressions downstream.
+   **Dot-path support** on the left side of `->`: full paths like `response.message.ts`, `response.data.user.email`, `Error.code` are emitted as-is. The first segment selects the top-level schema output; implementation then walks that output's nested schema one segment at a time and takes the emitted **`name` and `type` from the final leaf — never from the top-level parent, and never the dotted path itself**. `Error.Message -> errorMessage` emits `name: "Message"` (the leaf's display name, else its exact final segment) and the leaf's `type`; `name: "Error.Message"` and the parent's `type: "jsonSchema"` are both wrong. Full shape and worked example: [`impl-json.md` § Nested extract example](impl-json.md). A nested row references its top-level parent, so `Error.Message -> errorMessage` does NOT also auto-mint a bare `Error` output unless schema discovery independently adds `Error` as a bare output. Array indexing (`items[0]`) is NOT supported in v1 — fall back to consuming the array variable and using `=js:` expressions downstream.
 
    **Schema-discovered bare outputs** (no SDD row): emit an auto-mint item for a **top-level** Step 0 schema entry that the SDD does not bind (e.g., `Error` or a pre-expanded shortcut like Slack's `ts`). `id = var = value = camelCase(entry name)`. Source is the entry's pre-populated value verbatim. Never obtain this form from an SDD Outputs row. For non-top-level fields, require the SDD `->` operator with the full path instead.
    ```markdown
@@ -92,7 +94,7 @@ Before the Phase 1 approval gate, reject any `tasks.md` input item that wraps it
      - Error            # bare — references top-level Error entry; produces vars.error (source = entry's =Error)
    ```
 
-3. **Unresolved taskTypeId** — `tasks describe` unavailable. Follow [placeholder-tasks](../../../placeholder-tasks.md) — omit `inputs:`/`outputs:`, capture wiring intent in a fenced code block.
+3. **Unresolved taskTypeId** — `tasks describe` unavailable. Follow [placeholder-tasks](../../../placeholder-tasks.md) — write no `data.inputs[]` / `data.outputs[]`, and capture wiring intent in the entry's `wiringNotes` in `registry-resolved.json`.
 
 Do not fabricate names not in the SDD or `tasks describe`. Validation of variable existence happens at planning time (Phase 1) for `=` rows (target must exist in Case Variables); at implementation time (Phase 3) for `->` rows (deferred to io-binding validator).
 
@@ -110,7 +112,7 @@ For the full notation and expression prefixes, see [bindings-and-expressions.md]
 
 > **Note:** task INPUT bindings still use `<-` for cross-task references (`input <- "Stage"."Task".output`) — this is the planner-side notation for "this input value comes from another task's output." Task OUTPUT bindings use `->` for extract (`Field -> caseVar`) and `=` for set/compute/copy. Different directional conventions because inputs read from somewhere; outputs write to somewhere.
 
-### Canonical `tasks.md` output list
+### Canonical output list
 
 Record outputs on each task entry as one item per row. This is the common output-list grammar for every resolved task type. Project SDD-declared rows using the table above, then preserve each canonical item unchanged; append only genuinely additional schema-discovered fields as bare items:
 
@@ -125,7 +127,7 @@ Record outputs on each task entry as one item per row. This is the common output
 
 Do not reduce this to a comma-separated list of names: that representation loses the operator and destination required by implementation.
 
-> **Planner emits SDD-natural form; impl applies the per-sink canonical wrap.** Values in `tasks.md` use the natural prefix notation shown above — `=vars.X`, `=metadata.X`, `=bindings.X`, cross-task `<-`. The implementation step rewrites each value to its canonical sink form when constructing `caseplan.json` (e.g., `=js:(vars.X)` for connector body fields, `=js:metadata.X` for `=metadata` references in any sink that runs the JS evaluator). Full rule: [bindings-and-expressions.md § Canonical form per sink](../../../bindings-and-expressions.md#canonical-form-per-sink).
+> **The SDD carries natural form; impl applies the per-sink canonical wrap.** Values in the canonical form use the natural prefix notation shown above — `=vars.X`, `=metadata.X`, `=bindings.X`, cross-task `<-`. The implementation step rewrites each value to its canonical sink form when constructing `caseplan.json` (e.g., `=js:(vars.X)` for connector body fields, `=js:metadata.X` for `=metadata` references in any sink that runs the JS evaluator). Full rule: [bindings-and-expressions.md § Canonical form per sink](../../../bindings-and-expressions.md#canonical-form-per-sink).
 
 ## I/O table validation rules
 
@@ -133,16 +135,16 @@ Apply at planning time (Phase 1). The first two rules cover Inputs; the rest cov
 
 | Rule | Severity | Detail |
 |---|---|---|
-| `tasks.md` input item wraps its value in backticks or quotes the SDD `Binding` cell did not contain | ERROR | The SDD cell is a Markdown code span. Unwrap it and copy the contents verbatim. |
-| `tasks.md` input item separates name from value with `:` | ERROR | The separator is the operator itself — `<-` for a cross-task reference, `=` otherwise. |
+| A projected input item wraps its value in backticks or quotes the SDD `Binding` cell did not contain | ERROR | The SDD cell is a Markdown code span. Unwrap it and copy the contents verbatim. |
+| A projected input item separates name from value with `:` | ERROR | The separator is the operator itself — `<-` for a cross-task reference, `=` otherwise. |
 | `->` row's target case variable not in Case Variables table | ERROR | Outputs declare bindings, not new variables. Target must pre-exist. |
 | `=` row's target case variable not in Case Variables table | ERROR | Same — `=` writes to existing variable's slot. |
 | `->` row missing left-side Field | ERROR | `->` requires a schema field name on the left. |
 | `=` row has a non-empty Field column | ERROR | `=` rows have `—` (no field), since the source is the right-side expression, not a schema field. |
-| SDD row has a non-empty Field and blank / `—` Binding | ERROR | Bare output is not SDD syntax. AskUserQuestion; schema discovery may independently add the field to `tasks.md`. |
-| `tasks.md` output item starts with `—`, `->`, or `=` | ERROR | An SDD table placeholder or operator leaked into the left operand. Re-project the row using the mandatory table above. |
+| SDD row has a non-empty Field and blank / `—` Binding | ERROR | Bare output is not SDD syntax. AskUserQuestion; schema discovery may independently add the field as a bare auto-mint output. |
+| A projected output item starts with `—`, `->`, or `=` | ERROR | An SDD table placeholder or operator leaked into the left operand. Re-project the row using the mandatory table above. |
 | Per task: same target case variable appears in multiple Outputs rows | ERROR | No double-binding; one row per target var per task. Last-writer-wins is a runtime footgun. |
-| Any SDD Outputs row differs from its `tasks.md` item in operator or operand | ERROR | The handoff is lossy. Restore the exact SDD row before approval; this includes equal-name `field -> field`. |
+| Any SDD Outputs row differs from its projected item in operator or operand | ERROR | The projection is lossy. Restore the exact SDD row before approval; this includes equal-name `field -> field`. |
 
 ## Scoping
 

package/skills/uipath-maestro-case/references/registry-discovery.md

@@ -28,7 +28,7 @@ Direct cache-file inspection is the authoritative discovery method for this skil
 
 > **Design-time gate short-circuit.** When the same-session resolution ledger from the planner's Case Design Lane (SKILL.md Rule 15) carries a `gateDecision` for a resource, the gate below already ran — the USER answered it at the Case Review (`gateDecision` exists only for user-answered items; a defaulted `resolve at build` carries none and gets the full gate below). Execute the decision without re-asking: `pick:<name>` → bind that entry; `resolve-at-build` → placeholder path directly; `create-during-build` → the Create-on-Missing flow below as if the user picked `Create`. Re-ask ONLY when the entry is stale against the current SDD (carryover rules in [planning.md](planning.md)) or the cache no longer contains the picked entry.
 
-> **Hard gate.** If the planning-phase lookup batch returns ≥1 empty result (no match across all relevant cache files for any task / trigger / connector), STOP. Run AskUserQuestion before invoking any per-plugin Unresolved Fallback path or writing any placeholder T-entry.
+> **Hard gate.** If the planning-phase lookup batch returns ≥1 empty result (no match across all relevant cache files for any task / trigger / connector), STOP. Run AskUserQuestion before invoking any per-plugin Unresolved Fallback path or writing any placeholder element.
 
 Required prompt shape:
 
@@ -173,7 +173,7 @@ uip maestro case registry search "<Name>" --type <agent|api> --local --output js
 Then, in order:
 
 - **Verify** — reconcile the sibling's declared I/O (case-preserving names from `entry-points.json` per the warning above; agents: CLI-synced; api-workflows: build-kept-consistent — no CLI verb writes entry-point I/O, the builder back-fills it and `validate` won't flag drift) against the pinned contract → matched / missing-in-sibling / extra-in-sibling.
-- **Record** the reconciled contract into `tasks.md` + `registry-resolved.json` and resolve the task (taskTypeId/folder-path filled) — now a normal resolved task. `taskTypeId` holds the local audit-only `EntityKey` as a resolution marker only — **Phase 2 must NOT tenant-`tasks describe` it**; the I/O schema recorded here (from the sibling's `entry-points.json`) is authoritative, and [Phase 2 Step 9 Phase A](implementation.md) + the per-type Built-inline notes ([agent/impl-json.md](plugins/tasks/agent/impl-json.md), [api-workflow/impl-json.md](plugins/tasks/api-workflow/impl-json.md)) skip the gather for inline siblings. (The `caseplan.json` `data.inputs[]`/`data.outputs[]` write and the io-binding pass happen in Phase 2/3 when the resolved task is materialized, exactly like any other resolved resource — **NOT in Phase 1**.)
+- **Record** the reconciled contract into `registry-resolved.json` and resolve the task (taskTypeId/folder-path filled) — now a normal resolved task. `taskTypeId` holds the local audit-only `EntityKey` as a resolution marker only — **Phase 2 must NOT tenant-`tasks describe` it**; the I/O schema recorded here (from the sibling's `entry-points.json`) is authoritative, and [Phase 2 Step 9 Phase A](implementation.md) + the per-type Built-inline notes ([agent/impl-json.md](plugins/tasks/agent/impl-json.md), [api-workflow/impl-json.md](plugins/tasks/api-workflow/impl-json.md)) skip the gather for inline siblings. (The `caseplan.json` `data.inputs[]`/`data.outputs[]` write and the io-binding pass happen in Phase 2/3 when the resolved task is materialized, exactly like any other resolved resource — **NOT in Phase 1**.)
 - **Warn+diff** missing/extra into the completion report; **never block**. A **missing-in-sibling** pinned output means the Case Variable it feeds is never set — record in the completion report that any downstream reference (task input, condition, SLA) will resolve empty at runtime, so the user can decide to re-invoke the build to add the field or accept it. **Never auto-fabricate** the missing output to silence the warning.
 - **Bind** with `resourceKey="solution_folder.<Name>"` **and `folderPath` binding `default` = `""`** (runtime folder — empty = co-located; the `solution_folder` sentinel lives ONLY in `resourceKey`, NOT in `folderPath`, else runtime `folder not exist` — see [create-inline-common.md § Step 3](plugins/tasks/create-inline-common.md#step-3--binding-invariants)). It binds by name+folder, so `EntityKey` stays audit-only. **For a § 1c merged build, Record/resolve and Bind apply to EVERY task in the group** — one sibling; all N tasks bind to it, **sharing ONE deduped binding pair** (same resource → one pair, per [bindings § Deduplication](plugins/variables/bindings/impl-json.md#deduplication)), NOT N separate bindings.
 
@@ -253,7 +253,7 @@ If no match is found across all relevant cache files:
    # already executed during the gate's Force-pull branch:
    uip maestro case registry pull --force
    ```
-2. If still no match (or the user picked `Use placeholders for all`, and any creatable resource was not selected for Create), mark it in tasks.md: `[REGISTRY LOOKUP FAILED: <name> in <folder>]` and proceed to the per-plugin Unresolved Fallback path.
+2. If still no match (or the user picked `Use placeholders for all`, and any creatable resource was not selected for Create), mark it in `registry-resolved.json`: `[REGISTRY LOOKUP FAILED: <name> in <folder>]` and proceed to the per-plugin Unresolved Fallback path.
 
 ### 4. Return All Matches
 
@@ -296,10 +296,10 @@ After registry pull, `uip maestro case spec` is the unified metadata endpoint fo
 
 ## Output Contract
 
-The discovery result for each match should include the **entity identifier** (the value from the "Identifier field" column above) so `tasks.md` can reference it. For **connector** tasks the implementation agent writes this identifier into `data.typeId`. For **non-connector** tasks it is not written to the node — it stays in `registry-resolved.json` (audit) and the node references the resource via `data.name` / `data.folderPath` = `=bindings.<id>`.
+The discovery result for each match should include the **entity identifier** (the value from the "Identifier field" column above) so Phase 2 can reference it. For **connector** tasks the implementation agent writes this identifier into `data.typeId`. For **non-connector** tasks it is not written to the node — it stays in `registry-resolved.json` (audit) and the node references the resource via `data.name` / `data.folderPath` = `=bindings.<id>`.
 
 ### `registry-resolved.json` content discipline
 
-Structured log only — per Rule 9, each entry uses exact keys `{stage, task, taskType, cacheFile, searchQuery, matches, selected, rationale}`. The file may be re-ingested as a performance cache only after association by `stage` + `task` and the strict SDD match in [planning.md § Design-lane carryover](planning.md#step-2--locate-and-parse-the-design-document); it never overrides the SDD. Any free-form prose written here gets parroted back into `tasks.md`. `rationale` MUST explain the selection choice (e.g., `"exact name match in caseManagement folder"`); never use it for verify-text drafts, SDD-vs-spec field translations, or downstream-plugin-behavior claims.
+Structured log only — per Rule 9, each entry uses exact keys `{stage, task, taskType, cacheFile, searchQuery, matches, selected, rationale}`. The file may be re-ingested as a performance cache only after association by `stage` + `task` and the strict SDD match in [planning.md § Design-lane carryover](planning.md#step-2--locate-and-parse-the-design-document); it never overrides the SDD. `rationale` MUST explain the selection choice (e.g., `"exact name match in caseManagement folder"`); never use it for verify-text drafts, SDD-vs-spec field translations, or downstream-plugin-behavior claims.
 
 <!-- END: registry-discovery.md -->

package/skills/uipath-maestro-flow/.maintenance/README.md

@@ -4,56 +4,63 @@ Internal tooling and conventions for maintaining the `uipath-maestro-flow` skill
 
 ## Structure
 
-The skill is organized into three peer capabilities:
+The skill is organized into four peer capabilities:
 
 ```text
-SKILL.md                                ← capability router (universal rules + 3-bucket intent)
+SKILL.md                                ← capability router (universal rules + 4-bucket intent)
 references/
 ├── shared/                             ← cross-capability primitives
 │   ├── cli-commands.md                 ← flat CLI lookup
 │   ├── cli-conventions.md              ← --output json, login, FOLDER_KEY, etc.
 │   ├── file-format.md                  ← .flow JSON schema
 │   ├── variables-and-expressions.md    ← =js: Jint expressions
-│   └── node-output-wiring.md           ← canonical $vars wiring rule
+│   ├── node-output-wiring.md           ← canonical $vars wiring rule
+│   ├── action-nodes.md                 ← action-node boilerplate shared by plugin impl.md's
+│   └── ux-narration-and-todos.md       ← progress narration + todo engage rules
 ├── author/
 │   ├── CAPABILITY.md                   ← capability index
-│   └── references/                     ← author's supporting docs
-│       ├── greenfield.md               ← create-new-flow journey
-│       ├── brownfield.md               ← edit-existing-flow journey
-│       ├── editing-operations.md       ← strategy selection
-│       ├── editing-operations-json.md  ← Edit / Write recipes (default)
-│       ├── editing-operations-cli.md   ← CLI carve-outs
-│       ├── planning-arch.md            ← topology/plugin index
-│       ├── planning-impl.md            ← registry/binding/wiring
-│       └── plugins/                    ← per-node-type planning + impl
+│   ├── greenfield.md                   ← create-new-flow journey
+│   ├── brownfield.md                   ← edit-existing-flow journey
+│   ├── editing-operations.md           ← strategy selection
+│   ├── editing-operations-json.md      ← Edit / Write recipes (default)
+│   ├── editing-operations-cli.md       ← CLI carve-outs
+│   ├── planning-arch.md                ← topology/plugin index
+│   ├── planning-impl.md                ← registry/binding/wiring
+│   └── plugins/                        ← per-node-type planning + impl
 ├── operate/
 │   ├── CAPABILITY.md                   ← capability index
-│   └── references/                     ← operate's supporting docs
-│       ├── ship.md                     ← Studio Web upload + Orchestrator deploy
-│       ├── run.md                      ← debug + process run + job status/traces
-│       └── manage.md                   ← instance lifecycle (pause/resume/cancel/retry)
-└── diagnose/
+│   ├── ship.md                         ← Studio Web upload + Orchestrator deploy
+│   ├── run.md                          ← debug + process run + job status/traces
+│   └── manage.md                       ← instance lifecycle (pause/resume/cancel/retry)
+├── diagnose/
+│   ├── CAPABILITY.md                   ← capability index
+│   ├── troubleshooting-guide.md        ← diagnostic priority ladder
+│   └── failure-modes.md                ← pattern catalog (missing `=js:`, misshapen nodes, etc.)
+└── evaluate/
     ├── CAPABILITY.md                   ← capability index
-    └── references/                     ← diagnose's supporting docs
-        ├── troubleshooting-guide.md    ← diagnostic priority ladder
-        └── failure-modes.md            ← pattern catalog (MST-9107, MST-9061, etc.)
+    ├── commands-reference.md           ← `uip maestro flow eval` surface
+    ├── eval-sets-guide.md              ← eval set + data point design
+    ├── evaluators-guide.md             ← evaluator selection and config
+    ├── running-guide.md                ← Studio Web run start/status/results
+    └── upload-safety.md                ← never auto-upload to satisfy a prerequisite
 ```
 
-**Recursive pattern.** Skill = `SKILL.md` + `references/`. Capability = `CAPABILITY.md` + `references/`. The same "index next to its references" shape at two scales. Future capabilities (e.g., `governance/`) get the template for free.
+**Recursive pattern.** Skill = `SKILL.md` + `references/`. Capability = `CAPABILITY.md` + its sibling docs in the same folder. The same "index next to its references" shape at two scales. Future capabilities (e.g., `governance/`) get the template for free.
 
-**Convention:** each capability is a self-contained folder. Every file under `<capability>/references/` is implicitly that-capability-scoped — path = provenance. The `CAPABILITY.md` index is always at `<capability>/CAPABILITY.md` (uniform shape across all three).
+**Convention:** each capability is a self-contained folder. Every file in `<capability>/` is implicitly that-capability-scoped — path = provenance. The `CAPABILITY.md` index is always at `<capability>/CAPABILITY.md` (uniform shape across all four).
 
 ### Capability boundary
 
 - **Author** = on disk, locally, **without `uip login`** (`flow init`, `validate`, `format`, registry, JSON edits)
 - **Operate** = touches the cloud, **requires `uip login`** (`solution upload`, `flow debug`, `flow pack`, `process run`, `instance ...`)
 - **Diagnose** = postmortem on a failed run, **requires `uip login`** (`instance incidents`, `instance variables`, `instance asset`, `incident get`, `job traces`)
+- **Evaluate** = evaluations against a flow already in Studio Web; local eval-set/evaluator CRUD needs no login, **`eval run *` requires `uip login`** (`eval set`, `eval evaluator`, `eval run`)
 
-Author terminates at `validate` + `format` and hands off to Operate. Operate hands off to Diagnose when a run faults. Diagnose hands off back to Author for the underlying fix.
+Author terminates at `validate` + `format` and hands off to Operate. Operate hands off to Diagnose when a run faults. Diagnose hands off back to Author for the underlying fix. Evaluate attaches to a flow Operate has already uploaded.
 
 ### Capability-index template
 
-`AUTHOR.md`, `OPERATE.md`, `DIAGNOSE.md` all follow the same 6-section structure:
+Every `<capability>/CAPABILITY.md` follows the same 6-section structure:
 
 1. `# <Capability> — <one-line purpose>`
 2. `## When to use this capability`
@@ -80,7 +87,7 @@ Anchor links are computed exactly as GitHub does — getting them wrong silently
 | --- | --- | --- | --- |
 | `## 5. \`--folder-key\` requirement` | `#5--folder-key-requirement` | `#5---folder-key-requirement` | After `.` strips and backticks strip: `5 --folder-key requirement`. The space between `5` and `--` becomes a dash, joining the two literal dashes from `--folder-key` → 3 dashes |
 | `## Reused reference ID — cross-connection ID leakage` | `#reused-reference-id-cross-connection-id-leakage` | `#reused-reference-id--cross-connection-id-leakage` | The em-dash (`—`) is stripped (non-alphanumeric/space/dash), but the spaces on either side of it survive and both become dashes → 2 dashes |
-| `## MST-9107 — \`=js:\` prefix missing` | `#mst-9107-js-prefix-missing` | `#mst-9107--js-prefix-missing` | Backticks strip from around `=js:`, then the em-dash, `=`, and `:` strip (non-alphanumeric/space/dash). The space before and after the em-dash both survive → 2 consecutive dashes between `9107` and `js` |
+| `## \`variables.nodes[]\` missing → \`$vars.X.output\` resolves to undefined` | `#variablesnodes-missing-varsxoutput-resolves-to-undefined` | `#variablesnodes-missing--varsxoutput-resolves-to-undefined` | Backticks, `.`, `[`, `]`, `$` and the `→` all strip (non-alphanumeric/space/dash). The space before and after the arrow both survive → 2 consecutive dashes between `missing` and `varsxoutput` |
 
 ### Verifying anchor links
 
@@ -90,7 +97,7 @@ Run the anchor-checker script before committing changes that add or edit anchor
 bash .maintenance/check-anchors.sh
 ```
 
-Returns `anchors_checked=N anchors_bad=0` on success. Any non-zero `anchors_bad` lists which file → which target slug failed to resolve.
+Returns `anchors_checked=N anchors_bad=0` on success. Exits non-zero on any bad anchor. Any non-zero `anchors_bad` lists which file → which target slug failed to resolve. An anchor resolves against either a heading slug or an explicit `<a id="...">` / `<a name="...">` tag in the target file — GitHub honors both.
 
 ## Verifying file-path links
 
@@ -100,7 +107,7 @@ Run the link-checker script to catch broken `[text](path)` links:
 bash .maintenance/check-links.sh
 ```
 
-Returns `checked=N broken=M`. Both checkers skip links inside fenced code blocks and inline code spans, so example links in this README and in REFACTOR-PROPOSAL.md don't trigger false positives.
+Returns `checked=N broken=M`. Exits non-zero on any broken link. Both checkers skip links inside fenced code blocks and inline code spans, so example links in this README don't trigger false positives.
 
 ## Verifying link text agrees with link URL
 
@@ -251,7 +258,7 @@ The checkers are not currently wired into CI or pre-commit hooks. They are kept
 
 ## Reachability convention
 
-Plugin docs (`references/author/references/plugins/<name>/{planning,impl}.md`) are linked from `author/CAPABILITY.md` via **folder links** (e.g., `[connector](references/plugins/connector/)`), not individual file links. Agents navigating to the folder discover both `planning.md` and `impl.md` there. This satisfies practical 2-hop reachability from `SKILL.md`.
+Plugin docs (`references/author/plugins/<name>/{planning,impl}.md`) are linked from `author/CAPABILITY.md` via **folder links** (e.g., `[connector](references/plugins/connector/)`), not individual file links. Agents navigating to the folder discover both `planning.md` and `impl.md` there. This satisfies practical 2-hop reachability from `SKILL.md`.
 
 The depth checker (`check-depth.sh`) treats folder links as reachability for every `.md` file inside the folder, matching this agent-navigation model. A strict file-link-only reachability check would flag plugin docs as "unreachable" — that's a false negative.