Skip to content

fix(uipath-maestro-bpmn): read a process input through the start event's mapping - #4892

Merged
DevMomo merged 20 commits into
mainfrom
fix/bpmn-input-scope
Nov 18, 2026
Merged

DevMomo merged 20 commits into
mainfrom
fix/bpmn-input-scope

Conversation

@DevMomo

@DevMomo DevMomo commented Nov 18, 2026 •

Copy link
Copy Markdown
Contributor

Dogfood 2026-11-17, issue 6. Covers part of #9 (see below).

Problem

The canvas scopes a process input to the start event. A later step that reads vars.<inputId> shows "A variable is unresolved" in the designer. uip maestro bpmn validate still passes, with at most a VARIABLE_NOT_SET warning (none for a loop's collection) that agents wave off. Rule bpmn.variables.read-inputs-directly taught that read, and the InvoiceEscalation example and the queue pattern showed it. The shipped InvoiceEscalation gives 3× VARIABLE_NOT_SET on its own.

Source of truth is PO.Frontend develop (VariableValidationUtils.ts, VariableScopeUtils.ts, UnifiedBuildDataManager.tsx). A step can read root-scoped variables and upstream nodes' output rows. An input declared on the start event is neither. When the canvas adds an input, it writes a start-event output row (source: '=vars.<inputId>') into a variable scoped to the start event.

Fix

  • bpmn-runtime.md: replace the rule with bpmn.variables.inputs-through-start, which shows the canvas shape. Unlike a task row, a start-event row does not declare its variable, so the .var(…, { elementId }) is required (without it check fails EXPR_UNDECLARED_REF). In a canvas-made process, read the existing row's var; add no second row.
  • InvoiceEscalation.bpmn.ts and queue-distribution-guide.md now use that shape. Canvas engine: 0 errors (was 3× VARIABLE_NOT_SET on the example). The queue example validates with no VARIABLE_NOT_SET.
  • SKILL.md Critical Rule 11: one sentence for inputs, matching its outputs half; no new rule number.
  • draft-skeleton.md: a decision or a per-item box's collection reads the variable the start event maps an input into, and the skeleton writes that mapping; VARIABLE_NOT_SET is no longer an ignorable skeleton warning.
  • New task expressions/input_scope (parking fee), graded by check_inputs_declared.py (≥2 inputs the start event maps and a later step reads, so the scope check is not vacuous) and check_canvas_ready.py --check scope. The grader is fix(uipath-maestro-bpmn): author every expression as =js: (a plain = opens in the C# editor) #4891's exact copy; its canvas_ready task belongs to fix(uipath-maestro-bpmn): author every expression as =js: (a plain = opens in the C# editor) #4891 and is not in this PR.

Evidence

  • coder-eval red, before the fix: score 0.455, scope check FAIL (computeFee VARIABLE_NOT_SET).
  • coder-eval, rule in bpmn-runtime.md only: 2/3 (the failing run never opened the reference and read vars.<inputId> directly). That is why Critical Rule 11 in SKILL.md gets one sentence for inputs, matching what it already says for outputs.
  • coder-eval green, with the Rule 11 sentence: 5/5 at score 1.000 (before the review fixes).
  • Terminal parity (dogfood BPMN UC1 prompt verbatim, Claude Code, graded --check scope): 5/5 valid replicates pass. A 6th replicate failed, but its Skill tool loaded another worktree's skill copy with the old rule (harness leak, excluded).
  • After the review fixes (52c734e52): input_scope 4/4 and dogfood UC1 parity 4/4, all at score 1.000. The commits after it change draft-skeleton.md and add "(none for a loop's collection)" to Critical Rule 11 and bpmn-runtime.md (dropped again in ac0ce4f2c). The draft-skeleton smoke tasks pass on them (deterministic graders; the LLM judge needs CI).
  • d21c26052: input_scope 3/3 at score 1.000. Head (4ac71ca26, fix(uipath-maestro-bpmn): author every expression as =js: (a plain = opens in the C# editor) #4891's grader): input_scope 1/1 at score 1.000; the old and new grader give the same --check scope verdict on all 7 saved red and green runs.
  • Autopilot in Studio Web (sw-draft, alpha), on new projects.
    • Before, on the stock package (release a8b15ef850db): the 2026-11-17 dogfood repro (UC1 roulette, Haiku 5.5) showed "A variable is unresolved" on vars.betAmount * 2. Re-run on 2026-11-18, it was 3/3 canvas-clean: UC1 on Haiku twice, ParkingFee on Sonnet once. The models copied the end-event mapping into root variables. So stock is not deterministic, and the coder-eval red on main (0.455) is the reproducible before.
    • After, on the d21c26052 build (release 493707475fba): 3/3 canvas-clean (canvas engine 0 findings). UC1 on Haiku 5.5, ParkingFee on Sonnet 5.5, and a new library-fine prompt on GPT-6.1 Sol. Every run mapped inputs on the start event into .var(..., { elementId: 'Event_start' }) and read those downstream (betAmountIn, hoursIn, daysOverdueIn).
    • In the designer, ParkingFee's "Charge 3 per hour, max 20" step shows Math.min(vars.hoursIn * 3, …) with no unresolved marker. A debug run with inputs 10 hours and no pass succeeded (instance 1eba80a1-c39e-4a8a-b95e-0ee2ce82a599). The start event output HoursIn: 10, HasPassIn: false and the end event output Fee: 20, so the inputs arrived.
    • 4ac71ca26 (release f12badec68ed) and final head 0ef0b3b0b (release 978cfff25cd1): UC1 on Haiku 5.5 is canvas-clean (canvas engine 0 findings) both times and reads the inputs through the start mapping (betAmountIn/betColorIn, then betIn/amountIn). The commits after 4ac71ca26 change only bpmn-runtime.md and queue-distribution-guide.md wording.
    • Swap proof:
      • The in-iframe getBundledPluginReleases() indexSha256 equals shasum -a 256 dist/index.json: 493707475fba5326a02f1dd822250c5814610f37b079d4b77f6d8cc3c3b92f19 for d21c26052, f12badec68ed5d6a0a67568ac30808a07024c942cba0f5083c35b8e056250743 for 4ac71ca26, 978cfff25cd17f8e1aff69195b3c71dfdd194483f22fb5e39c34314de5450e37 for 0ef0b3b0b (stock: a8b15ef850db32fa217170afba8f46c1be91231a14cd2cdcc11c9754b413bd77).
      • :5052 …/uipath-maestro-bpmn/references/bpmn-runtime.md and the build copy are both sha1 e90383932b7096af4191a018383c8fee14a2d33f (d21c26052) 5940be7ead9500fd286d3dd77b71f8c75b31964e (4ac71ca26) and 01494e7fd0aee09c82d603fcee27cb099df87d51 (0ef0b3b0b).

#9

"Autopilot generated a BPMN that has validation issues" has no artifact attached. The warnings an Autopilot BPMN gets are VARIABLE_NOT_SET (this PR), the plain-= C# expressions (#7), maestroEngineVersion (#5), and the parse warning unknown attribute <type>. That last one also appears on the shipped examples and is not caused by this PR.

unknown attribute <type> traced: it comes from <uipath:inputSchema type="jsonSchema">, which .scriptTask() and .humanTask() write (InvoiceEscalation carries two, on post and approve; validate prints the warning once, and removing both attributes clears it). The canvas writes the same attribute (PO.Frontend develop, bpmn-moddle.ts createInputSchema), but its descriptor uipath-moddle.v1.json InputSchema declares only body. So the canvas warns on its own output. This is a PO.Frontend descriptor gap and harmless: neither the SDK nor the skill needs a change.

Follow-up (SDK)

.input() already scopes the input to the start event but doesn't emit the bridge, and a start-event payload row doesn't declare its own variable the way a task's output row does. If the SDK emitted the bridge, this rule would not be needed.

🤖 Generated with Claude Code

DevMomo and others added 11 commits November 17, 2026 18:11
…nd input scoping (WIP)

check_canvas_ready.py --check js|scope; canvas_ready.yaml grades the js half.
Dogfood 2026-11-17 issues 6 and 7.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…t's mapping

A process input belongs to the start event. A later step that reads
vars.<inputId> is "A variable is unresolved" on the Studio Web canvas, and
validate only warns VARIABLE_NOT_SET (dogfood 2026-11-17, issue 6). The
rule bpmn.variables.read-inputs-directly taught exactly that read, and the
InvoiceEscalation example and the queue pattern showed it.

Replace the rule with the canvas's own shape: map each input on the start
event into a variable scoped to it, then read that variable downstream.
Fix both examples and the draft-skeleton line the same way. Add the
input_scope task, graded by check_canvas_ready.py --check scope.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
With the rule only in bpmn-runtime.md, input_scope passed 2 of 3 runs. The
failing run never opened the reference and read vars.<inputId> directly.
Rule 11 already says outputs go out through the end event. Add the matching
sentence for inputs through the start event: 5 of 5 runs then pass.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Declare the snippet's written variable. Say why a start-event row needs a
`.var()`, unlike a task row. Read the existing mapping in a canvas-made
process. Draft decisions read the mapped variable. The eval now requires
declared inputs, so the scope check cannot pass on a process that has none.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
… may write the input mapping

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…oped to Event_start

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…rs only

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…, inputs never warn

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The count was wrong for one more start shape each round (mapped inputs,
input collections, timer and message starts). The warning text is enough.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…hrough the start mapping

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
… reading an input

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
@github-actions

github-actions Bot commented Nov 18, 2026 •

Copy link
Copy Markdown
Contributor

Claude finished @DevMomo's task in 59s —— View job


Coder-eval task lint (advisory)

2 task YAMLs changed. Verdicts: 0 Critical, 1 High, 0 Medium, 1 Low, 0 OK.

Rubric: .claude/commands/lint-task.md. This check is advisory and never blocks merge.

Evidence of passing run

  • ✅ input_scope: "Final head (d21c26052): input_scope 3/3 at score 1.000."
  • ❌ High: canvas_ready (skill-bpmn-expr-canvas-ready) is a new task in this PR (commit 90327f14b, titled "(WIP)"), but the PR body never mentions running it. Please add a line like: Ran skill-bpmn-expr-canvas-ready locally and it passed. If it is still WIP, consider dropping it from this PR.

Per-task lint

tests/tasks/uipath-maestro-bpmn/expressions/canvas_ready/canvas_ready.yaml — verdict: High

Issues:

  • [High] Evidence of passing run: no claim in the PR body (see above).
  • [Medium] Meaningful coverage: the description (L5–9) says each input is read through the start event's mapping and that "the grader checks the XML and validate's warnings". The only grader runs check_canvas_ready.py … --check js (L49), so input scoping goes ungraded here.
  • [Low] Meaningful coverage: nothing checks the discount logic (10% for Gold, 2% otherwise, returns price and savings). A schema-valid process that is all =js: but computes wrong values passes.

Suggested fixes:

  • Either rewrite the description to cover only the =js: contract, since input_scope already owns scoping, or drop --check js so the grader runs both checks and add the check_inputs_declared.py CheckoutDiscount.bpmn 2 guard.
  • Consider a light run_command that checks the BPMN contains 0.1/10 and 0.02/2 in a =js: expression or condition, plus two end-event output rows.

tests/tasks/uipath-maestro-bpmn/expressions/input_scope/input_scope.yaml — verdict: Low

Issues:

  • [Low] Could pass for the wrong reason: the scope check (L57) finds warnings by running a regex over the JSON-dumped validate report (check_canvas_ready.py:97, \[…\] VARIABLE_NOT_SET). If validate changes its message format, or Data comes back empty, the check passes without checking anything. The 0.455 red run shows it bites today, but a format drift would fail open without anyone noticing.
  • [Low] Meaningful coverage: the fee logic goes unchecked (pass holders pay 0, 3 per hour, cap 20).

Suggested fixes:

  • In check_canvas_ready.py, fail if validate's JSON has no recognizable diagnostics/warnings list, or match on a structured code field rather than the rendered text. That way an unexpected shape fails the check instead of passing it.
  • Consider asserting that a =js: expression references both 3 and 20 (e.g. Math.min).

Within-PR duplicates

  • No duplicate clusters detected. The two tasks reuse a scaffold but grade different contracts (--check js vs --check scope). If canvas_ready is changed to run both checks, it will cover everything input_scope checks. In that case, keep canvas_ready on --check js only.

Notes

  • CLI verb reachability: neither task has command_executed criteria, so this axis has nothing to check. I could not run scripts/check-cli-verbs.py in this job because the tool was not allowed.
  • Outside this PR's scope: sibling computed_js.yaml L33–35 tells the agent to "prefer plain =vars.<id>", but canvas_ready now says a plain = opens in the C# editor. Consider aligning that prompt in a follow-up.

Conclusion

  • ⚠ 2 tasks have issues, max severity High: canvas_ready has no passing-run claim, and its description and grader disagree. Advisory only, not blocking merge.

@github-actions

github-actions Bot commented Nov 18, 2026 •

Copy link
Copy Markdown
Contributor

Claude finished @DevMomo's task in 2m 25s —— View job


Summary

This PR replaces rule bpmn.variables.read-inputs-directly with bpmn.variables.inputs-through-start. A step now reads a process input through a .var() that the start event's BPMN.Variables row maps it into. The PR updates the two examples that read inputs directly, adds one sentence to Critical Rule 11, adjusts the draft-skeleton guidance, and adds two expressions/ smoke tasks. The main fix is sound and the eval evidence is solid. I found two Medium issues, both in the draft-skeleton text and in the extra canvas_ready task.

Change-by-Change Review

1. references/bpmn-runtime.md — new rule inputs-through-start

OK. The example is minimal. It states the EXPR_UNDECLARED_REF trap. It contrasts correctly with node-output-declares-itself ("Unlike a task's output row…"). It also covers the brownfield case ("read that row's var; add no second row"). No stale references to read-inputs-directly remain anywhere in skills/ or tests/. The changed passages sit outside every skill-flavor block, so the studioweb overrides inherit them unchanged.

  • Nit (Low): line 49 runs about 130 characters while its neighbours wrap at about 95.

2. references/draft-skeleton.md:213-216 — the "expected findings" text now contradicts itself

Medium. Line 213 says a skeleton may validate with Variable "vars.<id>" is read but never assigned warnings, and that these are expected and should not be chased. Line 216 then says to act on any VARIABLE_NOT_SET warning. That expected message almost certainly is VARIABLE_NOT_SET. Every skeleton example (vars.itemsBelowReorder, vars.documents, vars.documentFailed) reads a .var() that nothing assigns. If so, the agent has no rule for telling the expected warning from the one it must fix. It will either chase every skeleton warning, which defeats the "do not chase them" section, or ignore all of them, which defeats this fix.

  • Fix: tell the two cases apart by the variable, not by the code. Act on VARIABLE_NOT_SET only when the <id> it names is an .input() id (rule 7). Ignore it when <id> is a skeleton .var() whose producer is a blank box.
  • Low: neither skeleton example (lines 110-160) shows the new start-event mapping, so rule 7's "write that mapping" has no worked example in this file.

Fix this →

3. tests/.../expressions/canvas_ready/canvas_ready.yaml — out of scope, and it grades a rule the skill doesn't teach

Medium.

  • Out of scope: this task comes from the WIP commit 90327f14b and belongs to issue chore: compact skills #7 (plain = vs =js:). The PR body doesn't mention it.

  • Description doesn't match the grading: the description says it grades that "each input is read through the start event's mapping". Its only content criterion is check_canvas_ready.py … --check js, so input scope is never checked here.

  • The skill contradicts the grader: the --check js grader fails any plain = value. The skill still teaches plain =:

    • bpmn.expression.js-for-methods (bpmn-runtime.md:65) says plain = comparisons and vars.x reads work.
    • This PR's own queue example writes QueueItem: '=vars.item' and when: '=vars.itemOutcome == "failure"' (queue-distribution-guide.md:55-57).
    • InvoiceEscalation writes value: '=vars.invoiceIdIn'.

    An agent that follows the skill exactly should fail this task. The skill change that would make it pass (the chore: compact skills #7 fix) is not in this PR.

  • Fix: drop canvas_ready.yaml from this PR. Keep check_canvas_ready.py, because input_scope uses its --check scope mode. Land the task with the chore: compact skills #7 skill change instead.

4. SKILL.md Critical Rule 11

Low. The sentence restates the reference rule, including the "(none for a loop's collection)" detail. That falls under the reference-pointer guidance, but the evidence justifies it: 2/3 with the rule only in the reference, 5/5 with the sentence. Optional trim: drop the parenthetical diagnostics and keep the action plus the link.

5. examples/InvoiceEscalation.bpmn.ts, patterns/queue-distribution-guide.md

OK. Every downstream read moved to invoiceIdIn / item, and no vars.invoiceId read is left outside the mapping row. The variable table was updated, and the stale "validate warns VARIABLE_NOT_SET" line was removed. No existing grader matches =vars.queueItem or =vars.invoiceId, so nothing downstream breaks.

6. expressions/input_scope/ — task and graders

OK. It has the required tags (uipath-maestro-bpmn, smoke, mode:build, lifecycle:generate), a minimal prompt, and the ≥2 inputs guard against a vacuous pass. The --check scope path in check_canvas_ready.py correctly skips the js failure.

  • Low: check_inputs_declared.py doesn't check sys.argv, so a wrong invocation crashes with a traceback instead of FAIL:.

What's Missing

  • Stale grader comment: tests/tasks/uipath-maestro-bpmn/e2e/api_workflow_composition/check_shape.py:43-45 and :577-578 still say VARIABLE_NOT_SET on the start-scoped input is "expected BY CONSTRUCTION (the BPMN skill's own guidance)". That is no longer the skill's guidance (Low). The leniency itself can stay, but the comment should be updated.
  • A worked skeleton example that maps an input on Event_start (see feat: new coded agent skills #2).

Area Ratings

Area Status Notes
Frontmatter OK Unchanged
E2E Tests Issue canvas_ready grades an untaught contract and is out of scope; input_scope OK
Skill Body OK Rule 11 grew longer but is justified by evals
References & Assets Issue draft-skeleton expected-vs-actionable VARIABLE_NOT_SET is ambiguous
Repo Hygiene OK No secrets or personal paths; no new skill, so no CODEOWNERS or registry change needed; edits stay outside flavor blocks

Issues for Manual Review

  • Confirm the warning code behind Variable "vars.<id>" is read but never assigned. If it is not VARIABLE_NOT_SET, finding feat: new coded agent skills #2 drops to Low. uip is not installed on this runner, so I couldn't check.
  • Confirm that .var(id, type, { elementId }) compiles to a uipath:variable and not a uipath:input with elementId. Otherwise check_inputs_declared.py counts mapped vars as inputs, and the ≥2 guard passes when it shouldn't.
  • Row name convention: InvoiceEscalation uses the input's display name ('Invoice ID'), while the bpmn-runtime.md example uses the id ('amount', which has no display name). Both look consistent with "the input's display name", but someone should confirm this against canvas output.

Conclusion

Approve after the two Medium fixes. The core rule change is correct, well evidenced, and applied consistently. Before merge:

  1. Make the draft-skeleton VARIABLE_NOT_SET guidance distinguish input reads from skeleton .var() reads.
  2. Remove canvas_ready.yaml (or move it to the chore: compact skills #7 PR) so this PR doesn't ship a task the skill is guaranteed to fail.

@tmatup

tmatup commented Nov 18, 2026

Copy link
Copy Markdown
Member

Two notes from the SDK side (builder-sdk #2138 / #2144):

  1. Loop collections. The PR says validate gives no VARIABLE_NOT_SET for a direct input read in a loop's collection, and that's true. The canvas still resolves names there the same way as anywhere else, so it shows the read as unresolved. UiPath/builder-sdk#2142 (EXPR_ARGUMENT_REF) reports that case in check. It may be worth dropping "(none for a loop's collection)" from Critical Rule 11 / bpmn-runtime.md, so agents don't read it as permission. The gap is in validate, not in the rule.

  2. App-backed human tasks (separate follow-up, not for this PR). UiPath/builder-sdk#2147 makes .humanTask({ app, folder }) write the v2 task with app bindings. SKILL.md and references/bpmn-runtime.md currently say the SDK can't write an app-backed task. Once test(uipath-troubleshoot): add Excel Read Range dynamic-SheetName-empty scenario (branch 7) #2147 ships, those lines need updating.

DevMomo and others added 5 commits November 18, 2026 08:51
The js half of the grader belongs to #4891: its task fails here by design
and the two grader copies would conflict. input_scope uses --check scope,
whose logic is identical in both copies.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…ows self-declare

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
… after the rule it excepts

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…the start mapping

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

@dmetzgar dmetzgar left a comment

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Approving the rule itself; please reconcile it with open skills#4829 before either merges (inline), and see the #4891 contract-test comment for the merge order.

DevMomo added a commit that referenced this pull request Nov 18, 2026
…omputed result reads

- bpmn-runtime.md: js-everywhere keeps #4833's warning for plain = expressions an agent keeps or edits (.length reads null; use .Count; .length only inside =js:).
- Contract test: FORM_VALUE also exempts the start-event row source: '=vars.<inputId>', var: (#4892 writes these).
- Grader: RESULT_READ exempts only a bare result/response/Error/iterator path, so a computed plain expression fails --check js.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

@jiyangzh jiyangzh left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Recommendation: 🟢 Approved. The rule is correct and every input read in the skill now goes through the start event. Findings are minor.

What
Replaces bpmn.variables.read-inputs-directly with bpmn.variables.inputs-through-start. A step reads an input through a .var() that the start event's BPMN.Variables row maps it into. Updates InvoiceEscalation, the queue guide, Critical Rule 11 and draft-skeleton.md. Adds the input_scope eval.

Overall findings

  • minor: stale grader comment. tests/tasks/uipath-maestro-bpmn/e2e/api_workflow_composition/check_shape.py lines 44-45 and 578 still call VARIABLE_NOT_SET on a start-scoped input "expected BY CONSTRUCTION (the BPMN skill's own guidance)". The skill now says the opposite. Fix: reword both comments to say the leniency is for that grader only.
  • minor: input_scope cannot tell a process that maps its inputs from one that never reads them. Declaring two inputs and ignoring them passes. The fee logic is also ungraded. Fix: add a check that a =js: expression reads a start-mapped variable, and that 3 and 20 appear.
  • Overlap and merge order: #4891 edits the same six skill files and also adds check_canvas_ready.py (add/add conflict; the PR calls its copy identical). The examples here use plain = ('=vars.item' in the queue guide, '=vars.invoiceIdIn' in the form field). #4891 rewrites those to =js:. Land #4891 first and rebase. The start-row source: '=vars.<inputId>' stays plain; the grader exempts it. #4829 conflicts on the draft-skeleton.md warning rule (already agreed in thread). #4899 also edits SKILL.md and draft-skeleton.md.
  • Checked: all .input( examples in the skill now use the bridge (no direct read left). uip validate and the canvas message were not run; the canvas behavior rests on the PR's designer evidence.

tl;dr
Approve. Land after #4891 and settle #4829's wording. Two small test and comment fixes.

@rockymadden rockymadden left a comment

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

🟢 Approved: No blockers; 3 non-blockers remain.

What

  • Teaches start-event mappings for process inputs so downstream references resolve on the canvas.

Axes

Axis Blockers Non-blockers Top finding
Correctness & logic 0 0 none
Code quality & simplicity 0 0 none
Types & contracts 0 0 none
Tests & validation 0 2 Unused inputs pass the regression · tests/tasks/uipath-maestro-bpmn/expressions/input_scope/check_inputs_declared.py:18
Security 0 0 none
Architecture & design 0 0 none
Error handling & resilience 0 0 none
Interface, docs & compatibility 0 1 Existing task still teaches direct reads

Overall findings

💬 Non-blocker · Interface, docs & compatibility

tests/tasks/uipath-maestro-bpmn/e2e/api_workflow_composition/check_shape.py:43 and :578 still describe VARIABLE_NOT_SET on a direct start-input read as expected and consistent with the skill. This PR reverses that guidance.

Update the stale explanation and migrate the exemption/fixture to the documented bridge where applicable.

💬 Non-blocker · Tests & validation

The smoke run passes 28/32 tasks, below the 95% gate. The new input-scope task passes, but four other tasks fail. One registry-list check timed out; I could not establish the cause of the remaining failures.

Inspect the failed criteria and fix any regression, or document evidence that the failures are unrelated.

Validation

  • Checked the SDK/Designer input-scope contract, canonical guidance and frozen flavors. No drift found; no local execution.
  • The new task passes in CI; the red smoke run is recorded above.

tl;dr: The guidance is consistent. Strengthen the scope regression and update the stale task assumptions.

…; drop loop-collection aside

Unused inputs passed input_scope; now an input counts only when a start
event maps it and a later step reads the mapped var. check_shape's
comments no longer call VARIABLE_NOT_SET on an input the skill's guidance.
Re-sync check_canvas_ready.py with #4891.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
@DevMomo

DevMomo commented Nov 18, 2026

Copy link
Copy Markdown
Contributor Author

Review-body findings, fixed in ac0ce4f: check_shape.py comments now call not gating VARIABLE_NOT_SET that grader's leniency, not the skill's (jiyangzh, rockymadden); "(none for a loop's collection)" dropped from Critical Rule 11 and bpmn-runtime.md (tmatup). Smoke: the 4 failing tasks are unrelated to input scoping (2 registry list 30s timeouts, a loop drawn back into a fork, a "before retrying" next-action phrase); input_scope passes.

DevMomo and others added 3 commits November 18, 2026 13:10
…ce1a5a8

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…3954ee6

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…coping-cd22cb

# Conflicts:
#	skills/uipath-maestro-bpmn/references/patterns/queue-distribution-guide.md
@github-actions

Copy link
Copy Markdown
Contributor

skill-lint: 0 new errors, 1 new warning

Rule Location Message
warning AGENT-READ-TRUNCATED skills/uipath-maestro-bpmn/SKILL.md:1 40,336 bytes, 379 lines: Codex keeps 10,000 tokens (40,000 bytes) of one read. Split it or route to smaller files
What these rules check
  • AGENT-READ-TRUNCATED: Markdown files an agent reads should fit in one read of each target agent. Each agent caps what one read returns. Codex keeps 10,000 tokens, counted as UTF-8 bytes / 4, and drops the middle. Delegate's ReadFile, which LoadSkill also uses, returns the first 2,000 lines and at most 100,000 characters of them. Claude Code's Read returns the first ~25,000 tokens with a partial-view notice and, by default, refuses a whole file over 256 KB. Gemini CLI's read_file returns the first 2,000 lines and cuts lines over 2,000 characters. Past a cap the agent sees part of the file unless it reads it in pages. Split the file, or move detail into smaller references the skill routes to. SKILL.md is checked for Codex and Delegate only: Claude Code and Gemini load it whole when the skill activates. Claude Code's count is real tokens, estimated with claude_code_bytes_per_token; the others are exact.

Only what this PR adds is listed, compared with the commit it branched from; issues already on the base branch are not. Updated on every push.

@DevMomo
DevMomo merged commit cac07e7 into main Nov 18, 2026
50 of 52 checks passed
@DevMomo
DevMomo deleted the fix/bpmn-input-scope branch November 18, 2026 23:08
rockymadden added a commit that referenced this pull request Nov 19, 2026
Takes main's Critical Rule 11 (#4892: a step reads an input through the
start event's mapping) and keeps Rule 12 after it, without its no-edit
exception for VARIABLE_NOT_SET on an input, which #4892 makes a real
bug. Renumbers main's new flavor references to the main-file rule
(now 13).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
rockymadden added a commit that referenced this pull request Nov 19, 2026
… clean report

With #4892 an input VARIABLE_NOT_SET is fixed like any other warning, so
the final report no longer has a sentence for it. When validate keeps no
warning, the judge now requires the report to mention none.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

5 participants