@uipath/skills 1.196.0 → 1.197.0

package/skills/uipath-maestro-case/references/phased-execution.md

@@ -146,7 +146,8 @@ After re-entry:
    - Task entry conditions (depends on TaskIds from Phase 2)
    - Case exit conditions
 4. **SLA + escalation** — per [`plugins/sla/impl-json.md`](plugins/sla/impl-json.md). Group `tasks.md §4.8` by target (root or stage); write full `slaRules[]` in one mutation per target.
-5. **End-of-Phase-3 validator pass** — per [`implementation.md § Step 12`](implementation.md). Run Checks 1-3 (=vars.X resolution, Q10 II Out-arg producer presence, type mismatch). AskUserQuestion for unresolved references and pure orphan Out-args; option (d) "continue with best-effort emit" preserves forward progress. Never HALT.
+5. **In-expression marker resolution** — per [`plugins/variables/io-binding/impl-json.md § In-Expression Marker Resolution`](plugins/variables/io-binding/impl-json.md). After all outputs are minted/deduped and bindings/conditions/SLA are written, resolve every `vars.$xref('Stage','Task','output')` marker in `caseplan.json` to bare `vars.<var>` in one sink-blind whole-file pass (input payloads, conditions, SLA, connector bodies). Unresolved triple → ERROR.
+6. **End-of-Phase-3 validator pass** — per [`implementation.md § Step 12`](implementation.md). Run Checks 1-5 (=vars.X resolution, Q10 II Out-arg producer presence, type mismatch, surviving `$xref` markers, resolved-resource I/O completeness). AskUserQuestion for unresolved references (incl. `$xref` markers), pure orphan Out-args, and unbound required inputs / phantom output fields; option (c)/(d) "continue with best-effort emit" preserves forward progress. Never HALT.
 
 Phase 3 produces a `caseplan.json` that should pass authoritative validation. No hard stop on Phase 3 exit — agent proceeds directly to Phase 4.
 

package/skills/uipath-maestro-case/references/plugins/conditions/stage-exit-conditions/impl-json.md

@@ -94,6 +94,27 @@ The case pauses after the rule fires; the user picks the next stage from candida
 
 Routes the case back to the originating stage.
 
+### Divert into an exception lane (gated routing exit)
+
+To route the **origin** stage into a decision/signal-routed exception lane (the lane then returns via `return-to-origin`), the origin carries TWO mutually-exclusive exits: a gated divert (`marksStageComplete: false`) into the lane, and a completion gated by the inverse `IF`.
+
+```json
+// origin divert → exception lane (escalate path)
+{ "id": "Condition_xxxxxx", "displayName": "Escalate", "type": "exit-only",
+  "marksStageComplete": false, "exitToStageId": "Stage_<exceptionLane>",
+  "rules": [[ { "id": "Rule_xxxxxx", "rule": "selected-tasks-completed",
+    "selectedTasksIds": ["t_<deciderTask>"],
+    "conditionExpression": "=js:(vars.<signal> === <exception-value>)" } ]] }
+
+// origin completion (normal path) — gated by the inverse IF
+{ "id": "Condition_yyyyyy", "displayName": "Complete Rule 1", "type": "exit-only",
+  "marksStageComplete": true,
+  "rules": [[ { "id": "Rule_yyyyyy", "rule": "required-tasks-completed",
+    "conditionExpression": "=js:(vars.<signal> !== <exception-value>)" } ]] }
+```
+
+The exception lane's entry is `selected-stage-exited("<origin>") + IF =js:(vars.<signal> === <exception-value>)`, `Interrupting: Yes`, exiting via `return-to-origin`. The two origin exits MUST be mutually exclusive: an ungated completion → dual-fire (next stage + lane both enter); a gated completion with no divert → deadlock (escalate path has no exit). `<signal>` is read directly from the producing task's output (no §1.5 relay var). See [`sdd-generation-rules.md` § Logical integrity step 5](../../../sdd-generation-rules.md#logical-integrity--stage-graph).
+
 ## Rule-Type × marksStageComplete Matrix
 
 | `marksStageComplete` | `rule` | Required extra field |

package/skills/uipath-maestro-case/references/plugins/conditions/stage-exit-conditions/planning.md

@@ -35,6 +35,8 @@ Every stage with an **Exit Condition** declared in sdd.md gets its own stage-exi
 | `wait-for-user` | Exit requires manual user decision or approval. |
 | `return-to-origin` | Rework / exception loop — sends the case back to the previous stage. |
 
+> **Routing the origin INTO a decision/signal-routed exception lane.** The origin stage carries the route: a gated divert exit (`marks-stage-complete: false`, `selected-tasks-completed("<decider>")`, `conditionExpression =js:(<signal> === <exception-value>)`, `exit-to-stage-id` → the lane) PLUS its completion exit gated by the inverse `IF`. The two must be mutually exclusive (ungated completion → dual-fire; gated completion with no divert → deadlock). The lane returns via `return-to-origin`. See [stage-exit-conditions/impl-json.md § Divert into an exception lane](impl-json.md#divert-into-an-exception-lane-gated-routing-exit) and [`sdd-generation-rules.md` § Logical integrity step 5](../../../sdd-generation-rules.md#logical-integrity--stage-graph).
+
 ## Rule-Type Catalog (stage-exit scope)
 
 Allowed `ruleType` values depend on `marks-stage-complete`:

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

@@ -88,6 +88,12 @@ Build the uniqueness pool from EVERY `var` / `id` currently in `caseplan.json`.
 
 **Skip guard.** Rules with no `uipath.outputs[]` (connector configuration unresolved — see [`connector-trigger-common.md § Placeholder fallback`](../../../connector-trigger-common.md#placeholder-fallback)) contribute zero outputs to the pool and must be skipped during enumeration. Same skip pattern as placeholder tasks (`data:{}`).
 
+## Formal-arg slot ID format
+
+In/Out-arg formal slots (`variables.inputs[].id`, `variables.outputs[].id`) MUST start with a letter — mint as **`v` + 8 chars** from `[A-Za-z0-9]` (e.g. `vK3mNp9Qx`), same convention as task-input slots ([io-binding](../io-binding/impl-json.md)) and the FE. NOT a bare prefix-less random id.
+
+Rationale: the formal In-arg slot id surfaces in the case BPMN as `<uipath:input id="...">` and is dot-referenced via `=vars.<id>` (the bridge, § In argument). A prefix-less random id can lead with a digit → BPMN parser rejects it (`illegal ID <5AinMKBDm>`); C# identifier + XML NCName rules require a leading letter/underscore. Companion ids (`inputOutputs[].id`) keep the human-readable name (`applicantName`) and are already letter-leading — only the random formal-slot id needs the `v` prefix.
+
 ## Inputs the plugin reads at Phase 3 Step 6.2
 
 1. **`tasks.md`** variable T-entries — for category, type, default, sourceTrigger(s), sourceField(s)
@@ -149,8 +155,8 @@ For each variable T-entry in `tasks.md` that has **no `sourceTrigger` / `sourceT
 | SDD row | `root.inputs[]` | `root.outputs[]` | `root.inputOutputs[]` |
 |---|---|---|---|
 | `Category=Variable` (pure state, no trigger) | — | — | `{id: <sdd-name>, name: <sdd-name>, type: <type>, elementId: "root", default: <value if Default set>, custom: true}` |
-| `Category=In` (any trigger type — manual / timer / event) | `{id: <random9>, name: <sdd-name>, type: <type>, default: <value>, elementId: <triggerId>}` | — | `{id: <sdd-name>, name: <sdd-name>, type: <type>, elementId: <triggerId>}` (no `custom` — argument companion). Additionally write the **bridge** on `triggerNode.outputs[]` (see § In argument below). |
-| `Category=Out` (companion ALWAYS emitted — see § Out argument) | — | `{id: <random9>, name: <sdd-name>, type: <type>, var: <sdd-name>}` (formal-arg pointer) | `{id: <sdd-name>, name: <sdd-name>, type: <type>, default: <value or "">, elementId: "root"}` (no `custom`) |
+| `Category=In` (any trigger type — manual / timer / event) | `{id: v<random8>, name: <sdd-name>, type: <type>, default: <value>, elementId: <triggerId>}` | — | `{id: <sdd-name>, name: <sdd-name>, type: <type>, elementId: <triggerId>}` (no `custom` — argument companion). Additionally write the **bridge** on `triggerNode.outputs[]` (see § In argument below). |
+| `Category=Out` (companion ALWAYS emitted — see § Out argument) | — | `{id: v<random8>, name: <sdd-name>, type: <type>, var: <sdd-name>}` (formal-arg pointer) | `{id: <sdd-name>, name: <sdd-name>, type: <type>, default: <value or "">, elementId: "root"}` (no `custom`) |
 | `Category=InOut` | (not supported in v1 — see SDD template) | (not supported in v1) | (not supported in v1) |
 
 > Loop A and Loop B can write the SAME `root.inputOutputs[]` entry when an SDD row appears in both contexts (e.g., a `Category=Variable` row with `sourceTrigger`). Apply dedup by `id`: if an entry with the same `id` already exists from Loop A, do not re-write in Loop B; Phase 2 validator has already confirmed there's no Type/Default conflict.
@@ -218,7 +224,7 @@ Three entries — formal slot + companion + bridge:
 
 ```json
 // 1. root.inputs[]  — formal-arg slot (caller writes here at fire, OR initialized via default for event triggers)
-{ "id": "<random9>", "name": "applicantName", "type": "string",
+{ "id": "v<random8>", "name": "applicantName", "type": "string",
   "default": "", "elementId": "<triggerId>" }
 
 // 2. root.inputOutputs[]  — companion (readable as =vars.applicantName)
@@ -226,11 +232,11 @@ Three entries — formal slot + companion + bridge:
   "elementId": "<triggerId>" }
 
 // 3. triggerNode.data.uipath.outputs[]  — bridge from formal slot to companion
-{ "name": "applicantName", "type": "string", "source": "=vars.<random9>", "var": "applicantName" }
+{ "name": "applicantName", "type": "string", "source": "=vars.v<random8>", "var": "applicantName" }
 // No `id`, no `elementId` on bridge — FE convention. `type` matches the SDD row's Type column.
 ```
 
-**Why three entries instead of one?** The runtime resolver (`VariablesService.findVariableByVariableId`) is a single string-equality find on `Variable.id`. The caller (or trigger fire for event triggers) writes the formal-arg's value into `vars.<random9>` at trigger fire (because `inputs[].id` is `<random9>`); downstream code wants to read it as `=vars.applicantName` (because that's the readable name). There is no automatic forwarding between the two slots — the bridge entry on `triggerNode.outputs[]` executes the copy at fire time: `source: "=vars.<random9>"` reads the formal slot, `var: "applicantName"` writes to the companion's slot. Without the bridge, `=vars.applicantName` resolves to undefined. The companion's `inputOutputs[]` entry alone declares the *name* in the namespace, but holds no *value* because nobody writes to it.
+**Why three entries instead of one?** The runtime resolver (`VariablesService.findVariableByVariableId`) is a single string-equality find on `Variable.id`. The caller (or trigger fire for event triggers) writes the formal-arg's value into `vars.v<random8>` at trigger fire (because `inputs[].id` is `v<random8>`); downstream code wants to read it as `=vars.applicantName` (because that's the readable name). There is no automatic forwarding between the two slots — the bridge entry on `triggerNode.outputs[]` executes the copy at fire time: `source: "=vars.v<random8>"` reads the formal slot, `var: "applicantName"` writes to the companion's slot. Without the bridge, `=vars.applicantName` resolves to undefined. The companion's `inputOutputs[]` entry alone declares the *name* in the namespace, but holds no *value* because nobody writes to it.
 
 > **Placeholder trigger interaction:** if the trigger is a placeholder (any type), write entries 1 + 2 only; skip the bridge (entry 3) — the placeholder has no `data.uipath.outputs` array. The placeholder trigger never fires, so the bridge would never execute anyway. **Consequence:** at runtime `vars.<name>` (the companion slot) is undefined — the `default` on the `inputs[]` formal slot does NOT propagate to the companion without the bridge. This is expected: a placeholder case is structurally incomplete and not meant to run until the trigger is resolved. Re-generate from scratch (Rule 6) after the trigger resolves to get the working bridge.
 
@@ -257,7 +263,7 @@ Same shape regardless of Default presence (two entries):
 
 ```json
 // 1. variables.outputs[]  — formal Out-arg pointer
-{ "id": "<random9>", "name": "finalDecision", "type": "string",
+{ "id": "v<random8>", "name": "finalDecision", "type": "string",
   "var": "finalDecision" }
 // var is a POINTER — at case end, engine reads vars.finalDecision via this pointer
 
@@ -277,17 +283,17 @@ Combines In + Out. One shared companion serves both:
 
 ```json
 // 1. root.inputs[]  — formal In slot
-{ "id": "<random9-in>", "name": "claimId", "type": "string",
+{ "id": "v<random8-in>", "name": "claimId", "type": "string",
   "default": "", "elementId": "<triggerId>" }
 
 // 2. root.inputOutputs[]  — shared companion
 { "id": "claimId", "name": "claimId", "type": "string", "elementId": "<triggerId>" }
 
 // 3. root.outputs[]  — formal Out slot pointing at same companion
-{ "id": "<random9-out>", "name": "claimId", "type": "string", "var": "claimId" }
+{ "id": "v<random8-out>", "name": "claimId", "type": "string", "var": "claimId" }
 
 // 4. triggerNode.outputs[]  — bridge from In formal slot to shared companion
-{ "name": "claimId", "type": "string", "source": "=vars.<random9-in>", "var": "claimId" }
+{ "name": "claimId", "type": "string", "source": "=vars.v<random8-in>", "var": "claimId" }
 ```
 
 Caller writes value; bridge copies to companion at trigger fire; task body updates `vars.claimId`; case end returns updated value to caller.

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

@@ -1,6 +1,6 @@
 # I/O Binding — Implementation
 
-> **Phase split.** Phase 3 only (Step 9.8). Phase 2 writes task shape (schema with empty `value` fields) but does not bind values. See [`../../../phased-execution.md`](../../../phased-execution.md).
+> **Phase split.** Phase 3 only. Input/output binding at Step 9.8; in-expression `vars.$xref` marker resolution at Step 11.5 (after conditions + SLA). Phase 2 writes task shape (schema with empty `value` fields) but does not bind values. See [`../../../phased-execution.md`](../../../phased-execution.md).
 
 Wire task inputs by editing `caseplan.json` directly. Runs after all tasks are created and enriched (Step 9) and after global variable + output wiring is complete.
 
@@ -15,7 +15,7 @@ Wire task inputs by editing `caseplan.json` directly. Runs after all tasks are c
   "value": "=vars.customerId" }
 ```
 
-Inputs are populated with empty `value` from the `tasks describe` schema when the task's `data.inputs[]` are written during the task plugin's impl-json write. Input IDs are random (`v` + 8 chars).
+Inputs are populated with empty `value` from the `tasks describe` schema when the task's `data.inputs[]` are written during the task plugin's impl-json write. Input IDs are random (`v` + 8 chars) — letter-leading, same convention as variable formal slots ([global-vars § Formal-arg slot ID format](../global-vars/impl-json.md#formal-arg-slot-id-format)).
 
 ## Task Output Shape
 
@@ -90,7 +90,29 @@ src_output = find_output_by_name(src_task, "outputName")
 target_input["value"] = f"=vars.{src_output['var']}"
 ```
 
-After all bindings, run the end-of-Phase-3 validator. It performs three cross-reference checks:
+## In-Expression Marker Resolution (Step 11.5)
+
+Whole-value `<-` (above) only resolves an input whose value IS the reference. To reference an upstream output from **inside** a `=js:` expression (composite payload, `conditionExpression`, SLA `expression`, computed `=` output, connector body field), the SDD embeds a `vars.$xref('Stage','Task','output')` marker — see [bindings-and-expressions.md § In-expression references](../../../bindings-and-expressions.md#in-expression-references-varsxref). Resolve all markers in **one pass over the whole `caseplan.json`** at **Step 11.5** — after conditions (Step 10) and SLA (Step 11) are written, and every task/trigger/rule output is minted and deduped (so the marker resolves to the final, suffixed `var`). This is the LAST mutation of Phase 3 before the validator; running it earlier (e.g. right after Step 9.8 input binding) misses markers in conditions / SLA and reads pre-dedup `var` ids.
+
+This single sink-blind pass replaces per-sink resolution: it walks every string value regardless of which sink holds it, so conditions, SLA, inputs, and connector bodies are all covered in one place.
+
+```text
+# pseudocode — not executed. Realize via Read → reason → Write/Edit.
+TOKEN = /vars\.\$xref\('([^']+)','([^']+)','([^']+)'\)/   # global, all matches
+
+for each string value V anywhere in caseplan.json:
+    for each match (stageLabel, taskName, outputName) of TOKEN in V:
+        src_stage  = find_node_by_label(nodes, stageLabel)        # data.label
+        src_task   = find_task_by_name(src_stage, taskName)       # displayName
+        src_output = find_output_by_name(src_task, outputName)    # data.outputs[].name
+        if any lookup fails: leave token unsubstituted — Check 4 (validator) surfaces it via AskUserQuestion
+        replace the matched token with "vars." + src_output["var"]   # bare, no leading "="
+    write V back
+```
+
+Resolution semantics are identical to whole-value `<-` (same name-triple, same lookup), with two differences: the substitution is **bare** `vars.<var>` (the marker already sits inside `=js:`), and it happens in a global string pass rather than against a single input's `value`. Exception-stage / adhoc scoping (reference any task across any stage) applies unchanged.
+
+After this pass and all bindings, run the end-of-Phase-3 validator. It performs the cross-reference checks below:
 
 ### Check 1 — `=vars.X` reference resolution
 
@@ -161,7 +183,7 @@ for entry in root.outputs[]:
 **On AskUserQuestion ("pure orphan" branch):**
 
 ```
-Out-argument "<name>" (id <random>, var <var>) has no value source:
+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
@@ -202,6 +224,107 @@ See [implementation.md § Step 12 — End-of-Phase-3 validator pass](../../../im
 
 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).
 
+### Check 4 — No surviving `$xref` markers
+
+Scan every string value in `caseplan.json` for the literal token `$xref(`. The [Step 11.5 pass](#in-expression-marker-resolution-step-115) should have resolved them all; any survivor means its name-triple failed to resolve (typo'd stage / task / output name). This is the same class of failure as a Check 1 unresolved `=vars.X` — so it gets the **same interactive remediation**, NOT a silent ERROR. Never ship a marker to runtime (`vars.$xref(...)` throws — a method call on `vars`).
+
+**On AskUserQuestion** (present the outputs that DO exist on the named task as candidates — same diagnostic shape as a failed whole-value `<-`):
+
+```
+In-expression reference $xref('<stage>','<task>','<output>') does not resolve:
+  Stage  "<stage>":  <found | NOT FOUND>
+  Task   "<task>":   <found | NOT FOUND in that stage>
+  Output "<output>": NOT FOUND on task
+  Available outputs on "<task>": <name, name, ...>
+  Used in: <sink — e.g. entry condition on stage "Approve" | input "payload" on task "Notify">
+
+Pick one:
+  (a) Name the intended output — supply the correct output name (or full Stage / Task / output triple).
+  (b) Edit the SDD expression — the marker is one term in a larger =js: expression; the upstream output genuinely does not exist.
+  (c) Continue with best-effort emit — token left unsubstituted; case builds; the =js: expression throws at runtime until fixed.
+```
+
+**Skill response per pick:**
+
+- **(a)** Rewrite the marker's triple in place in `caseplan.json` with the corrected name(s), re-run the [Step 11.5](#in-expression-marker-resolution-step-115) resolution for that token, then re-scan. If it still fails, re-prompt.
+- **(b)** Edit the SDD expression as directed, re-run the Phase 1 dispatcher from the modified SDD, then retry Step 11.5 + this check.
+- **(c)** Leave the token unsubstituted, append the build-issues entry (template below), continue to Phase 4. No re-run.
+
+**Build-issues entry template:**
+
+```markdown
+## Open Items for User
+
+- **[Unresolved `$xref` marker]** — `vars.$xref('<stage>','<task>','<output>')` in <sink> did not resolve (output not found on the named task). The `=js:` expression throws at runtime until fixed. Correct the source output name in the SDD and rebuild.
+```
+
+### Check 5 — Resolved-resource I/O completeness
+
+Verifies each resolved task's binding contract **covers** its resource's declared I/O — the build-side re-check of [sdd-generation-rules.md § Resolved-resource I/O completeness](../../../sdd-generation-rules.md#resolved-resource-io-completeness) (Approve-gate item 9 / Finalization step 19). Where Checks 1–4 verify that references which *exist* resolve, Check 5 verifies the *right set of references exists*: required inputs are not silently missing, and extract outputs name real fields.
+
+Read each resolved task's persisted contract from `tasks/registry-resolved.json` (per-input `name` + `required` flag, declared output-field list — written at §Resolve). **Skip** any task with no persisted contract (Rule 17 placeholder / `<UNRESOLVED>`) — same treatment as Check 2's unresolved-producer branch.
+
+```text
+# pseudocode — not executed. Realize via Read → reason → Write/Edit.
+for task in caseplan.json tasks where contract = registry_resolved[task].contract is present:
+    bound_inputs = { inp.name : inp.value for inp in task.data.inputs[] }
+    # (a) required-input coverage
+    for decl in contract.inputs where decl.required:
+        v = bound_inputs.get(decl.name)
+        if v is missing or v == "":            # no row, or row with empty value
+            ERROR → AskUserQuestion (unbound-required-input)
+    # (b) output-field fidelity
+    declared_out = set(contract.outputs[].name)
+    for out in task.data.outputs[]:            # extract rows: source = "=<path>"
+        leaf = top_level_segment(strip_leading_"=", out.source)   # strip envelope prefix: response. / Error. / data.
+        if leaf not in declared_out:
+            ERROR → AskUserQuestion (phantom-output-field)
+```
+
+An **upstream-output-fed** required input is covered like any other — its `value` is `=vars.<var>` (whole-value `<-`) or sits inside a `=js:` (resolved `$xref`); a non-empty `value` passes. Do NOT expect a §1.5 declaration for it.
+
+**On AskUserQuestion — unbound required input:**
+
+```
+Required input "<field>" on task "<task>" (resource "<resource>") is not bound:
+  Declared by the resource as required; no Inputs row with a value in the case plan.
+  Other required inputs on this task: <bound / unbound list>
+
+Pick one:
+  (a) Bind it — supply the source: a case variable, a literal, or an upstream task's output ("Stage"."Task".out). Skill writes the Inputs row and binds it.
+  (b) Mark <UNRESOLVED> — record a placeholder + a high review item; case builds, this input is runtime-null until wired.
+  (c) Continue with best-effort emit — leave it unbound; entry logged under Open Items; the job may fault at runtime.
+```
+
+**On AskUserQuestion — phantom output field:**
+
+```
+Output field "<field>" extracted by task "<task>" is not in resource "<resource>"'s declared outputs:
+  Available outputs on this resource: <name, name, ...>
+  Used in: outputs row "<field> -> <caseVar>"
+
+Pick one:
+  (a) Name the intended output — pick from the available list; skill rewrites the extract Field + re-resolves.
+  (b) Drop the extract row — the case does not consume this output.
+  (c) Continue with best-effort emit — left as-is; entry logged under Open Items; the extract resolves to runtime null.
+```
+
+**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.
+- 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.
+
+**Build-issues entry templates:**
+
+```markdown
+## Open Items for User
+
+- **[Unbound required input]** — task "<task>" (resource "<resource>") input "<field>" is required but unbound; resolves to runtime null. Bind it in the SDD and rebuild.
+- **[Phantom output field]** — task "<task>" extracts "<field>", which resource "<resource>" does not emit; resolves to runtime null. Correct the output name in the SDD and rebuild.
+```
+
 ## Connector Tasks
 
 Connector task input values are written during Step 9.7 (connector detail), not during this I/O binding step. Resolve cross-task `var` IDs before constructing the `input-values` body from `tasks.md`, then apply the canonical wrap per sink:
@@ -242,8 +365,12 @@ All issues go to the shared issue list per [logging/impl-json.md](../../logging/
 | Placeholder connector rule (no `rule.uipath.outputs[]`) | `SKIPPED` | Skip rule output bindings (nothing minted) |
 | Input name not found (exact match) | `ERROR` | Skip binding — log available inputs |
 | Source output not found (exact match) | `ERROR` | Skip binding — log available outputs |
+| `$xref(...)` marker name-triple fails to resolve (Step 11.5 / Check 4) | `ERROR` | Leave token unsubstituted; AskUserQuestion (Check 4 above) — log unresolved triple + available outputs |
 | `=vars.X` not in any task `outputs[].id` or root `inputOutputs[].id` / `inputs[].id` | `ERROR` | Skip binding |
 | Out-arg formal entry has NO producer (no extraction, assignment, or bare-name match in any task outputs) AND companion has no `default` | `ERROR` | Log Out-arg pure-orphan issue (Check 2 above); AskUserQuestion |
+| Resolved resource's **required** input has no bound `value` in the case plan (Check 5) | `ERROR` | AskUserQuestion (unbound-required-input) — bind / `<UNRESOLVED>`+review-item / best-effort |
+| Extract output `Field` absent from resolved output contract (Check 5) | `ERROR` | AskUserQuestion (phantom-output-field) — re-point / drop row / best-effort |
+| Resolved task has no persisted contract (placeholder / `<UNRESOLVED>`) | `SKIPPED` | Skip Check 5 for that task |
 | Type mismatch (input vs variable) | `WARNING` | Proceed |
 
 Example log entry (pseudocode — record in-reasoning, not via subprocess):