@uipath/maestro-builder-sdk 6.42.0 → 6.43.0

package/dist/check.js

@@ -5,19 +5,16 @@
  * duplicate step names, references to undeclared variables/steps, empty branch
  * arms, and missing terminals.
  */
-import { Expr, SCHEDULE_PRESETS, parseIxpProjectType, flatNameOf, flatNameSegmentsOf, FLAT_SEP } from './flow-sdk.js';
+import { Expr, SCHEDULE_PRESETS, parseIxpProjectType } from './flow-sdk.js';
 import { FlowNode } from './core/node-classes.js';
 import { planContributionBindings } from './core/contribution-bindings.js';
 import { definitionHasErrorPort, errorPortRefusal } from './core/error-port.js';
-import { actionVersion, bundledActionNodeType, bundledContainerDefinition, bundledDefinition, perCallDefinition, resolveContributionDefinition } from './serialize.js';
-import { FORM_FIELD_TYPES, formFieldOptionsProblem, formFieldOptionsWhy, formFieldSettingProblems, formFieldTypeHint, formFieldTypeWhy, validFormFieldTypesText, } from './core/form-field-type.js';
+import { bundledActionNodeType, bundledContainerDefinition, bundledDefinition, perCallDefinition, resolveContributionDefinition } from './serialize.js';
 import { checkEventResolution, checkEventSubscription, eventParamsFor, } from './core/event-checks.js';
 import { checkCookedEscapes } from './flow-expr-check.js';
 import { FLOW_EXPR_DIALECT, checkBindingLabels, checkBindingPresence, checkConnectorContract as coreCheckConnectorContract, checkConnectorLookups as coreCheckConnectorLookups, checkConnectorSchema as coreCheckConnectorSchema, collectConnectionUses, connectionConnectorConflicts, } from './core/connector-checks.js';
-import { prepareCommand } from './core/cli-spelling.js';
 import { commentText } from './core/comment-text.js';
 import { nearestName } from './core/edit-distance.js';
-import { renamedFieldMessage } from './core/process-resource.js';
 import { hitlDerivesOutcomeHandles, hitlExitModel, hitlRoutesPerOutcome, outcomeIdOf } from './core/hitl-routing.js';
 import { hasExits } from './core/step-ports.js';
 import { stopsAtEnd } from './flow-step-tree.js';
@@ -25,7 +22,6 @@ import { FLOW_SCHEMA_VERSIONS } from './format-profile.js';
 import { compareSchemaVersions, schemaVersionRefusal } from './schema-version.js';
 import { planFlowGlobals, planSharedInputs, sharedInputRoots } from './flow-variables.js';
 import { planOutputBacking } from './flow-output-backing.js';
-import { ownEntry } from './core/own-entry.js';
 import { terminateStepClashMessage, terminateTwiceMessage } from './flow-terminate-names.js';
 import { endContentKey } from './flow-end-content.js';
 import { FLOW_NODE_TYPES } from './flow-node-registry.js';
@@ -34,7 +30,6 @@ import { plainHttpOnErrorMessage } from './nodes/http/flow/family.js';
 import { resolveVersion, resolveVersionCarried } from './core/nodes/versioned.js';
 import { declaredErrorPortRefusal } from './core/error-port.js';
 import { bodyUsesBreak, loopParallelWarning, loopVersionRefusal } from './loop-version.js';
-import { derivedResourceNodeId } from './core/agent-resource-identity.js';
 const newResourceIdLedger = () => ({ explicit: new Map(), taken: new Map(), agentSources: new Map() });
 /** INLINE_AGENT_RESOURCE_NODE_ID for each explicit `nodeId` another node of the file also gets. */
 function resourceNodeIdClashes(ledger) {
@@ -453,7 +448,7 @@ function checkFlow(built, ancestors, opts = {}, ledger = newResourceIdLedger())
                 prevPortSource = s;
                 const registered = registeredKind(s.spec);
                 if (registered) {
-                    const { placed, checked } = checkRegisteredStep(registered, s, exprs, errorSource, opts, diags, typeOf, triggerId, carriedLookup([built, ...ancestors]));
+                    const { placed, checked } = checkRegisteredStep(registered, s, exprs, errorSource, opts, diags, typeOf, triggerId, ledger, carriedLookup([built, ...ancestors]));
                     checkedSteps.set(s.name, checked);
                     if (placed)
                         registeredSteps.set(s.name, checked);
@@ -514,22 +509,10 @@ function checkFlow(built, ancestors, opts = {}, ledger = newResourceIdLedger())
                         });
                     }
                 }
-                if (s.spec.kind === 'createOutgoingCall' || s.spec.kind === 'endCall' || s.spec.kind === 'voiceAgent') {
-                    checkVoice(s.name, s.spec.kind, s.spec.inputs, diags);
-                }
-                if (s.spec.kind === 'conversationalAgent') {
-                    checkConversationalAgent(s.name, s.spec.inputs, diags);
-                }
                 // The process family checks the step itself; the flow-level fire-and-forget
                 // read rule below needs to know which steps dispatch without waiting.
                 if (s.spec.kind === 'agenticProcess')
                     agenticProcesses.set(s.name, s.spec.inputs);
-                if (s.spec.kind === 'agent') {
-                    checkAgent(s.name, s.spec.inputs, diags);
-                }
-                if (s.spec.kind === 'inlineAgent') {
-                    checkInlineAgent(s.name, s.spec.inputs, diags, opts, ledger);
-                }
                 {
                     const rule = OUTPUT_READ_RULES[s.spec.kind];
                     if (typeof rule === 'function') {
@@ -2097,7 +2080,6 @@ function codeOnly(src) {
     code(false);
     return out.join('');
 }
-const GUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 /**
  * A read of an API workflow's output: `out('<step>', '<field>')`.
  *
@@ -2112,132 +2094,6 @@ const GUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/
  *  - reading something other than `output` (e.g. `$vars.<step>.result`), which the
  *    job never publishes.
  */
-/**
- * A conversational AGENT step (Phase 5).
- *
- * The turn wiring is the whole risk: `'simple'` mode reads everything out of
- * ONE conversation-context binding, so a flow that names neither the context
- * nor the individual fields deploys an agent with no transcript to answer.
- */
-function checkConversationalAgent(step, inputs, diags) {
-    const at = (code, message, suggestion) => {
-        diags.push({ level: 'error', code, message, step, ...(suggestion ? { suggestion } : {}) });
-    };
-    const blank = (v) => v === undefined || v === null || (typeof v === 'string' && v.trim() === '');
-    if (blank(inputs?.model)) {
-        at('CONV_AGENT_NO_MODEL', `Conversational agent step "${step}" has no \`model\`, which the node's definition requires. `
-            + `\`uip agent model list\` shows what the tenant offers.`, `model: 'gpt-5.4'`);
-    }
-    if (blank(inputs?.systemPrompt)) {
-        at('CONV_AGENT_NO_PROMPT', `Conversational agent step "${step}" has no \`systemPrompt\` — the agent has no instructions for how `
-            + `to answer the person.`, `systemPrompt: 'You are a support agent. Be brief.'`);
-    }
-    const st = inputs?.settings;
-    const mode = st?.mode ?? 'simple';
-    if (mode !== 'simple' && mode !== 'custom') {
-        at('CONV_AGENT_SETTINGS_MODE', `Conversational agent step "${step}"'s settings mode is ${JSON.stringify(mode)}. Valid: 'simple' (one `
-            + `conversation-context binding) or 'custom' (bind each field yourself).`);
-        return;
-    }
-    const named = ['context', 'conversationId', 'exchangeId', 'messages', 'userSettings']
-        .filter((k) => st !== undefined && !blank(st[k]));
-    if (named.length === 0) {
-        at('CONV_AGENT_NO_TURN', `Conversational agent step "${step}" binds nothing in \`settings\` — it would run with no transcript and `
-            + `no conversation to answer into. In 'simple' mode bind the whole context from a wait or context step.`, `settings: { context: out('<waitStep>', 'conversationContext') }`);
-    }
-    else if (mode === 'custom' && blank(st?.conversationId)) {
-        at('CONV_AGENT_CUSTOM_NO_ID', `Conversational agent step "${step}" binds its turn field-by-field ('custom' mode) but names no `
-            + `\`conversationId\` — the one field the platform's own editor marks required, because the reply has `
-            + `nowhere to go without it.`, `settings: { mode: 'custom', conversationId: out('start', 'conversationId'), … }`);
-    }
-}
-/**
- * A VOICE step (Phase 5D): create-outgoing-call, end-call, or the voice agent.
- *
- * Two things are decidable offline and expensive later: a call needs both
- * numbers in a form the telephony provider accepts, and every voice step needs
- * the `callContext` OBJECT — binding a bare conversation id instead is the
- * classic mistake, because the field is typed `object` and a string passes the
- * file's schema while failing at dispatch.
- */
-function checkVoice(step, kind, inputs, diags) {
-    const at = (code, message, suggestion) => {
-        diags.push({ level: 'error', code, message, step, ...(suggestion ? { suggestion } : {}) });
-    };
-    const blank = (v) => v === undefined || v === null || (typeof v === 'string' && v.trim() === '');
-    if (kind === 'createOutgoingCall') {
-        for (const field of ['from', 'to']) {
-            const raw = inputs?.[field];
-            if (blank(raw)) {
-                at('CALL_NO_NUMBER', `createOutgoingCall step "${step}" has no \`${field}\`, which the node's schema requires — `
-                    + `${field === 'from' ? 'the provisioned number the call comes from' : 'the number to dial'}.`, `${field}: '+15551234567'`);
-                continue;
-            }
-            // A literal number is checkable; an expression is the caller's business.
-            if (typeof raw === 'string' && !/^\+[1-9]\d{6,14}$/.test(raw.trim())) {
-                diags.push({
-                    level: 'warning', code: 'CALL_NUMBER_NOT_E164', step,
-                    message: `createOutgoingCall step "${step}"'s \`${field}\` is ${JSON.stringify(raw)}, which is not `
-                        + `E.164 (a leading '+' and 7–15 digits). Telephony providers reject anything else at dispatch, `
-                        + `so a run fails after the flow is deployed.`,
-                    suggestion: `${field}: '+15551234567'`,
-                });
-            }
-        }
-        return;
-    }
-    // end-call and the voice agent are both keyed by the live call.
-    if (blank(inputs?.callContext)) {
-        at('VOICE_NO_CALL_CONTEXT', `${kind === 'endCall' ? 'endCall' : 'voiceAgent'} step "${step}" has no \`callContext\`, which the node's `
-            + `schema requires — it identifies the live call. The incoming-call trigger publishes it as `
-            + `out('start', 'callContext'), and createOutgoingCall as out('<dialStep>', 'callContext').`, `callContext: out('start', 'callContext')`);
-    }
-    else {
-        const cc = inputs.callContext;
-        const js = cc instanceof Expr && !cc.literal ? cc.js : undefined;
-        // The field is the call-context OBJECT. A read that ends at a scalar inside
-        // it (`…callContext.conversationId`, or a bare conversation id) passes the
-        // file's schema and then fails at dispatch.
-        if (js !== undefined && /\.(conversationId|id)\s*$/.test(js)) {
-            at('VOICE_CALL_CONTEXT_NOT_OBJECT', `${kind === 'endCall' ? 'endCall' : 'voiceAgent'} step "${step}"'s \`callContext\` reads `
-                + `"${js.trim()}", which is a field INSIDE the call context rather than the context object itself. `
-                + `The node's schema types it \`object\`; a scalar passes the file's schema and fails at dispatch.`, `callContext: out('start', 'callContext')`);
-        }
-    }
-    if (kind === 'voiceAgent') {
-        if (blank(inputs?.systemPrompt)) {
-            at('VOICE_AGENT_NO_PROMPT', `voiceAgent step "${step}" has no \`systemPrompt\` — a caller is waiting, and the agent has no `
-                + `instructions for what to say.`, `systemPrompt: 'Greet the caller and find out why they called.'`);
-        }
-        const mi = inputs?.maxIterations;
-        if (mi !== undefined && !(mi instanceof Expr)) {
-            const n = Number(mi);
-            if (!Number.isInteger(n) || n < 1 || n > 8) {
-                at('VOICE_AGENT_ITERATIONS', `voiceAgent step "${step}"'s \`maxIterations\` is ${JSON.stringify(mi)}. The node's schema allows `
-                    + `1 to 8 — a tighter ceiling than a text agent's, because the caller is waiting on the turn.`, `maxIterations: 4`);
-            }
-        }
-        const v = inputs?.voice;
-        if (v !== undefined) {
-            const PERSONAS = {
-                'gemini-3.1-flash-live-preview': ['Aoede', 'Charon', 'Fenrir', 'Kore', 'Leda', 'Orus', 'Puck', 'Zephyr'],
-                'gpt-realtime-2': ['alloy', 'ash', 'ballad', 'coral', 'echo', 'sage', 'shimmer', 'verse'],
-            };
-            const model = typeof v.model === 'string' ? v.model : undefined;
-            // An own-key read: `in` also matched 'toString', and `PERSONAS[model].includes` then threw.
-            const personas = model !== undefined ? ownEntry(PERSONAS, model) : undefined;
-            if (model !== undefined && personas === undefined) {
-                at('VOICE_MODEL_UNKNOWN', `voiceAgent step "${step}" names the voice model ${JSON.stringify(model)}. The platform's catalog `
-                    + `today is ${Object.keys(PERSONAS).map((m) => `'${m}'`).join(' and ')} — a voice model, not one of `
-                    + `the text models an inline agent takes.`);
-            }
-            else if (typeof v.persona === 'string' && personas !== undefined && !personas.includes(v.persona)) {
-                at('VOICE_PERSONA_UNKNOWN', `voiceAgent step "${step}"'s persona ${JSON.stringify(v.persona)} is not one of `
-                    + `${JSON.stringify(model)}'s voices (${personas.join(', ')}). A persona belongs to its model.`);
-            }
-        }
-    }
-}
 /**
  * The read rule the process-shaped families share: the result is published
  * under `output`, keyed by a known field list — the author's `returns`, or a
@@ -2298,8 +2154,8 @@ const OUTPUT_READ_RULES = {
     apiWorkflow: { exempt: 'Registered: its node type reads its own output (nodes/process/flow/, a `reader` contract).' },
     publishedFunction: { exempt: 'Registered: its node type reads its own output (nodes/process/flow/, a `reader` contract).' },
     agenticProcess: { exempt: 'Registered: its node type reads its own output (nodes/process/flow/, a `reader` contract).' },
-    agent: checkAgentRead,
-    inlineAgent: checkInlineAgentRead,
+    agent: { exempt: 'Registered: its node type reads its own output (nodes/process/flow/, a `reader` contract).' },
+    inlineAgent: { exempt: 'Registered: its node type reads its own output (nodes/agent/flow/, a `reader` contract).' },
     queueItem: { exempt: 'Registered: its node type states the fields a read may name (nodes/queue/flow/, a `fields` output contract).' },
     script: {
         exempt: 'Not yet: only the field-map form of a script\'s `returns` gives a list to check against (the '
@@ -2307,885 +2163,6 @@ const OUTPUT_READ_RULES = {
             + 'its own false-positive sweep — flow-builder-sdk#855.',
     },
 };
-/**
- * Check an `agent(...)` call — a published or in-solution agent (coded or
- * low-code).
- *
- * WHAT THESE RULES CAN AND CANNOT SEE. Whether the agent exists, which kind it is,
- * and what it returns all live on the tenant. So these cover what is decidable from
- * the call — and two of them are the exact classes v1's own baseline on this family
- * fails on, which is why they are errors rather than warnings:
- *
- *  - **A reference to nothing.** 5 of 16 `skill-flow-coded-agent` runs in the
- *    06-29 → 07-20 window emitted an agent node whose `resourceKey` was a LOCAL
- *    project id and whose `folderPath` was `""`, and faulted at job start with
- *    `[170007] … HTTP 404 "The job's associated process could not be found"`. A
- *    blank `name` or `folderPath` is that flow, caught before a tenant round trip.
- *  - **The empty-input floor.** `inputs` is required by the type, so `{}` is the only
- *    way to reach it, and it is worth saying what the platform then does — see
- *    `AGENT_EMPTY_INPUT_FLOOR`.
- *
- * What no rule here can see: whether the agent's ANSWER is right. That is CP-3's
- * ruling — a green live rung means a model responded with the declared shape — and
- * the gate that does cover a flow FAKING an answer is an offline `replays:` seed
- * asserting the exact unfixtured value, not a check.
- */
-function checkAgent(step, inputs, diags) {
-    const at = (code, message, suggestion) => {
-        diags.push({ level: 'error', code, message, step, ...(suggestion ? { suggestion } : {}) });
-    };
-    const blank = (v) => v === undefined || v === null || (typeof v === 'string' && v.trim() === '');
-    const inSolution = inputs?.location === 'in-solution';
-    if (blank(inputs?.key) && !blank(inputs?.agent)) {
-        at('AGENT_NO_KEY', renamedFieldMessage('Agent', step, 'agent'), `key: ${JSON.stringify(inputs.agent)}`);
-    }
-    else if (blank(inputs?.key)) {
-        at('AGENT_NO_KEY', `Agent step "${step}" has no \`key\`. It is a GUID and becomes part of the node's `
-            + `type — without it there is no agent to start. For a published agent, find the Orchestrator `
-            + `release with \`uip or processes list --all-folders --limit 200\` (take the row's \`Key\`) or `
-            + `\`uip maestro flow registry search uipath.core.agent\`. For an in-solution agent, read `
-            + `\`resource.key\` from \`resources/solution_folder/process/agent/<project>.json\`.`, `key: '6a47dc5b-5fd4-461f-b97d-6c1817abcaaa'`);
-    }
-    else if (!GUID_RE.test(String(inputs.key).trim())) {
-        at('AGENT_KEY_NOT_GUID', `Agent step "${step}"'s \`key\` is ${JSON.stringify(inputs.key)}, which is not a key. \`key\` is `
-            + `the GUID the tenant gives the published agent (it becomes the node type's suffix); the agent's NAME `
-            + `goes in \`name\` and its folder in \`folderPath\`. Passing a ProcessKey like `
-            + `"CountLetters.CodedAgent.agent.CountLetters" here is the common form of this — that string is the `
-            + `row's \`ProcessKey\`, not its \`Key\`.`, `key: '<guid>', name: ${JSON.stringify(inputs.key)}`);
-    }
-    if (blank(inputs?.name)) {
-        at('AGENT_NO_NAME', `Agent step "${step}" has no \`name\`. The runtime resolves the agent's release by name + folder, not `
-            + `by the key in the node type, so without it the job cannot start — deployed, that is `
-            + `\`[170007] … 404 The job's associated process could not be found\`.`, `name: 'CountLetters LowCode Agent'`);
-    }
-    if (!inSolution && blank(inputs?.folderPath)) {
-        at('AGENT_NO_FOLDER', `Agent step "${step}" has no \`folderPath\`. The runtime resolves the agent by listing ONE Orchestrator `
-            + `folder, so a blank folder resolves nothing — and an empty \`folderPath\` is the exact shape of v1's `
-            + `commonest live failure on this node type (5 of 16 runs, 06-29 → 07-20: `
-            + `\`[170007] … 404 The job's associated process could not be found\`). It is also what disambiguates `
-            + `two same-named agents: this tenant has \`CountLetters\` in both \`Shared\` and `
-            + `\`Shared/uipath-maestro-flow/CountLetters CodedAgent\`.`, `folderPath: 'Shared/uipath-maestro-flow/CountLetters LowCode'`);
-    }
-    if (inSolution && blank(inputs?.projectId)) {
-        at('AGENT_LOCAL_NO_PROJECT_ID', `In-solution agent step "${step}" has no \`projectId\`. Read \`resource.projectKey\` from `
-            + `\`resources/solution_folder/process/agent/<project>.json\` after registering the sibling `
-            + `with \`uip solution projects add\`.`, `projectId: '<resource.projectKey>'`);
-    }
-    else if (inSolution && !GUID_RE.test(String(inputs.projectId).trim())) {
-        at('AGENT_LOCAL_PROJECT_ID_NOT_GUID', `In-solution agent step "${step}" has projectId ${JSON.stringify(inputs.projectId)}, which is not `
-            + `the registered sibling project's GUID. Read \`resource.projectKey\` from the generated resource file.`, `projectId: '<resource.projectKey>'`);
-    }
-    const name = typeof inputs?.name === 'string' ? inputs.name.trim() : '';
-    if (name.includes('/')) {
-        at('AGENT_NAME_IS_PATH', `Agent step "${step}"'s \`name\` is ${JSON.stringify(name)}, which looks like a folder path. \`name\` is `
-            + `the agent's own name in Orchestrator; the path it lives in goes in \`folderPath\`. Together they form `
-            + `the resourceKey "<folderPath>.<name>", so swapping them points the job at nothing.`);
-    }
-    // The platform's SECOND place for rewriting an agent node's inputs behind the
-    // author's back (the first is the reserved-key class — see AGENTIC_RESERVED_INPUT).
-    // A warning rather than an error: an argument-less agent is legal, and the floor
-    // makes it work. What is not acceptable is that it happen silently.
-    if (inputs?.inputs && Object.keys(inputs.inputs).length === 0) {
-        diags.push({
-            level: 'warning',
-            code: 'AGENT_EMPTY_INPUT_FLOOR',
-            message: `Agent step "${step}" binds no inputs. The platform does not send an empty body for an agent the way `
-                + `it does for the other job families — flow-v1's \`applyEmptyInputFloor\` seeds `
-                + `\`JobArguments: { input: "" }\` (or \`{}\` / \`[]\`, typed off the agent's declared \`input\` field), `
-                + `because the Python agent runner validates the body against a schema with a REQUIRED \`input\` field `
-                + `and rejects a bare \`{}\` with "Field required: input" — the pod then exits 0x33. So the deployed `
-                + `node carries an argument named \`input\` that you did not write, and which is not in the agent's own `
-                + `schema unless it happens to declare one. Locally the envelope passes straight through, so no rung `
-                + `sees the difference. Bind the agent's own arguments if it takes any.`,
-            step,
-        });
-    }
-    if (inputs?.returns && Object.keys(inputs.returns).length === 0) {
-        diags.push({
-            level: 'warning',
-            code: 'AGENT_EMPTY_RETURNS',
-            message: `Agent step "${step}" declares \`returns: {}\` — an empty contract, which emits no output schema at `
-                + `all and so reads exactly like omitting it. If the agent returns nothing, drop the key; if it `
-                + `returns something, name the fields (\`uip maestro flow registry get uipath.core.agent.`
-                + `${inputs.key}\` shows them under outputDefinition.output.schema.properties).`,
-            step,
-        });
-    }
-}
-/**
- * A read of a published agent's output: `out('<step>', '<field>')`.
- *
- * The three mistakes are api-workflow's and agentic-process's, plus a fourth this
- * family owns: a read whose CASE differs from the declared field. That is worth its
- * own message because for a while it was a live-only defect rather than a mistake —
- * a poller that read the job through `uip agent run status` got a PascalCased
- * envelope, so `output.Count` was right live and wrong offline while
- * `output.count` was the reverse (flow-builder-sdk #122). Now the agent's own field
- * names arrive verbatim and the wrong case is simply undefined; naming it as a CASE
- * problem rather than an unknown field is the difference between a two-second fix and
- * a re-read of the registry.
- */
-function checkAgentRead(name, field, rest, spec, step, diags) {
-    if (field === undefined)
-        return; // `out('call')` — the whole output object.
-    if (field === 'error')
-        return; // the error envelope every agent node declares.
-    if (field !== 'output') {
-        diags.push({
-            level: 'error',
-            code: 'AGENT_READ_NOT_OUTPUT',
-            message: `Agent "${name}" publishes the job's output arguments under "output", but `
-                + `"$vars.${name}.${field}" (read in "${step}") asks for "${field}", which is undefined at run time.`,
-            step,
-            suggestion: `out('${name}', '<field>')`,
-        });
-        return;
-    }
-    const declared = Object.keys(spec.returns ?? {});
-    const wanted = (rest ?? '').replace(/^\./, '').split('.')[0];
-    if (!wanted)
-        return; // `$vars.<name>.output` — the whole object.
-    if (declared.length === 0) {
-        diags.push({
-            level: 'error',
-            code: 'AGENT_READ_WITHOUT_RETURNS',
-            message: `"$vars.${name}.output.${wanted}" (read in "${step}") reads a field of agent "${name}"'s result, but `
-                + `the step declares no \`returns\` — so the node carries no output schema and nothing can tell a real `
-                + `field from a typo. The agent's output fields live on the tenant; declare the ones you read. `
-                + `\`uip maestro flow registry get uipath.core.agent.${spec.key}\` shows them under `
-                + `outputDefinition.output.schema.properties.`,
-            step,
-            suggestion: `returns: { ${wanted}: 'string' }`,
-        });
-        return;
-    }
-    if (declared.includes(wanted))
-        return;
-    const caseMatch = declared.find((d) => d.toLowerCase() === wanted.toLowerCase());
-    if (caseMatch) {
-        diags.push({
-            level: 'error',
-            code: 'AGENT_READ_WRONG_CASE',
-            message: `Agent "${name}" declares "${caseMatch}", not "${wanted}" (read as "$vars.${name}.output.${wanted}" `
-                + `in "${step}") — the same field, the wrong case. An agent answers with the field names its own `
-                + `definition declares, and a read is case-sensitive on every rung, so this is undefined everywhere.`,
-            step,
-            suggestion: `out('${name}', '${caseMatch}')`,
-        });
-        return;
-    }
-    const nearest = nearestName(wanted, declared);
-    diags.push({
-        level: 'error',
-        code: 'AGENT_READ_UNKNOWN_FIELD',
-        message: `Agent "${name}" declares no output "${wanted}" (read as "$vars.${name}.output.${wanted}" in "${step}"). `
-            + `Its \`returns\` names: ${declared.join(', ')}. A read outside that set is undefined on every rung and `
-            + `on the platform.`,
-        step,
-        ...(nearest ? { suggestion: `out('${name}', '${nearest}')` } : {}),
-    });
-}
-// ─── an inline agent's prompt asking for JSON text ───────────────────────────────
-//
-// The phrase table behind `INLINE_AGENT_PROMPT_JSON_TEXT`. It is kept narrow on
-// purpose, because the rule is an error. Three shapes count, and each skips a
-// negation anywhere earlier in the same clause ("Do not return JSON", "Do not wrap
-// the answer in JSON", "Return the items, not as JSON"):
-//
-//  - DIRECT: an output verb, then only words from a closed qualifier list, then
-//    `json` — "Return ONLY a JSON object", "Return only the typed JSON contract".
-//  - VIA: an output verb, up to two words, then `as` / `in` / `with`, qualifiers,
-//    `json` — "Format your answer as JSON", "Respond with valid JSON".
-//  - BRACE: a quoted-key brace whose key is one of the step's own `returns` keys —
-//    `Return ONLY {"category","priority"}` next to `returns: { category, priority }`.
-//
-// A word outside the qualifier list ends a DIRECT match, so JSON as DATA does not
-// count in the DIRECT form: "Answer the question using the JSON data below", "Give
-// a summary of the JSON ticket", "Return the invoice number from the JSON". The VIA
-// form allows two free words, so it can still fire on JSON as a topic ("Answer in
-// Spanish with JSON examples"); the tail skips the common data nouns after `json`
-// (keys, data, record, examples, input) and the JSON-family FORMATS a string field
-// legitimately holds (JSON Schema, JSON Patch, JSON-LD, JSON Lines, …). `write` is
-// not a verb here: "You help users write JSON" is a topic, not an answer shape.
-//
-// The skills repo's preview-doc gate (tests/tasks/uipath-maestro-flow/_shared/
-// test_preview_inline_agent_prompts.py) ports this table to Python and loads a
-// byte-identical copy of tests/fixtures/inline-agent-prompt-vectors.json, so
-// change the table, the fixture and the port together.
-const JSON_TEXT_VERBS = 'return|respond|reply|output|answer|produce|emit|format|give|provide';
-/** Words that are only ever qualifiers of the answer's shape, never the thing it is about. */
-const JSON_TEXT_QUALIFIERS = [
-    'only', 'just', 'exactly', 'strictly', 'solely', 'simply', 'a', 'an', 'one', 'single', 'the',
-    'your', 'its', 'this', 'that', 'valid', 'raw', 'pure', 'plain', 'strict', 'compact', 'minified',
-    'well-formed', 'properly', 'formatted', 'typed', 'declared', 'structured', 'following', 'same',
-    'final', 'back', 'proper', 'correct', 'machine-readable', 'parseable', 'parsable',
-];
-/** A negation anywhere earlier in the same clause, or anywhere in the match's gap. */
-const JSON_TEXT_NEGATIONS = new Set(['not', 'never', 'no', 'dont', 'without', 'rather', 'instead', 'avoid']);
-const isJsonTextNegation = (w) => JSON_TEXT_NEGATIONS.has(w) || w.endsWith("n't") || w.endsWith('n’t');
-const JSON_TEXT_WORD = "[A-Za-z][\\w'’-]*";
-/** Words are separated by spaces, tabs or a comma — never a newline or a full stop. */
-const JSON_TEXT_SEP = '[ \\t]*,?[ \\t]+';
-const JSON_TEXT_QUAL = `(?:${[...JSON_TEXT_QUALIFIERS].sort((a, b) => b.length - a.length).join('|')})\\b`;
-// `(?<![-\w])` skips `--output json`; `(?!\.\w)` skips `JSON.parse` / `JSON.stringify`;
-// `(?!-(?:ld|rpc)\b)` skips JSON-LD / JSON-RPC (`\b` matches before the hyphen);
-// the last lookahead skips "the JSON below" / "the JSON provided" / "the JSON you
-// get", data nouns ("the JSON keys", "JSON examples") and JSON-family formats
-// ("JSON Schema", "JSON Patch", "the JSON path", "a JSON Web Token").
-const JSON_TEXT_TAIL = `json\\b(?!\\.\\w)(?!-(?:ld|rpc)\\b)(?![ \\t]+(?:below|above|provided|given|you`
-    + `|keys?|data|records?|examples?|inputs?`
-    + `|schemas?|patch|path|pointer|lines|rpc|web[ \\t]+tokens?)\\b)`;
-const JSON_TEXT_VERB = `(?<![-\\w])(?:${JSON_TEXT_VERBS})\\b`;
-const JSON_TEXT_DIRECT = new RegExp(`${JSON_TEXT_VERB}((?:${JSON_TEXT_SEP}${JSON_TEXT_QUAL}){0,5})${JSON_TEXT_SEP}${JSON_TEXT_TAIL}`, 'gi');
-const JSON_TEXT_VIA = new RegExp(`${JSON_TEXT_VERB}((?:${JSON_TEXT_SEP}${JSON_TEXT_WORD}){0,2}?)${JSON_TEXT_SEP}(?:as|in|with)`
-    + `((?:${JSON_TEXT_SEP}${JSON_TEXT_QUAL}){0,4})${JSON_TEXT_SEP}${JSON_TEXT_TAIL}`, 'gi');
-const escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-/**
- * The phrase in `text` that tells a model to answer in JSON TEXT, or `undefined`.
- *
- * `check` uses it for `INLINE_AGENT_PROMPT_JSON_TEXT`, passing the step's `returns`
- * keys so the brace form only counts a brace that spells one of them. Without
- * `returnKeys` (the example and doc sweeps) any quoted identifier key counts.
- * `{{input.*}}` placeholders are removed first, so an input named `json` never
- * matches.
- *
- * @example
- * ```ts
- * jsonTextDirective('Return ONLY a JSON object with keys "subject" and "body".'); // 'Return ONLY a JSON'
- * jsonTextDirective('Return ONLY {"category","priority"}.', ['category']);       // '{"category",'
- * jsonTextDirective('Return a result conforming to the output schema.');          // undefined
- * jsonTextDirective('Do not return JSON.');                                       // undefined
- * jsonTextDirective('Answer the question using the JSON data below.');            // undefined
- * ```
- */
-export function jsonTextDirective(text, returnKeys) {
-    if (typeof text !== 'string' || text === '')
-        return undefined;
-    // A placeholder becomes a hard break (`·` is neither a word nor a gap), and a
-    // quoted or back-ticked `JSON` is read as the bare word.
-    const t = text
-        .replace(/\{\{\s*input\.[^}]*\}\}/g, ' · ')
-        .replace(/[`"'“”](json)[`"'“”]/gi, ' $1 ');
-    const words = (s) => (s.match(new RegExp(JSON_TEXT_WORD, 'g')) ?? []).map((w) => w.toLowerCase());
-    const keys = returnKeys?.length ? returnKeys.map(escapeRegExp).join('|') : '[A-Za-z_]\\w*';
-    const brace = new RegExp(`\\{[ \\t]*["'](?:${keys})["'][ \\t]*[,:}]`, 'g');
-    for (const rule of [JSON_TEXT_DIRECT, JSON_TEXT_VIA, brace]) {
-        rule.lastIndex = 0;
-        for (const m of t.matchAll(rule)) {
-            if (m.slice(1).some((g) => words(g ?? '').some(isJsonTextNegation)))
-                continue;
-            // Any negation earlier in the same clause: "Do not wrap the answer in JSON",
-            // "No need to return JSON". A comma ends a clause, so "Do not guess, return
-            // ONLY a JSON object" still counts.
-            const clause = t.slice(0, m.index).split(/[.;:!?\n,]/).pop() ?? '';
-            if (words(clause).some(isJsonTextNegation))
-                continue;
-            return m[0].trim();
-        }
-    }
-    return undefined;
-}
-/**
- * Check an `inlineAgent(...)` call.
- *
- * The interesting difference from every other node this SDK authors: **nothing here
- * lives on a tenant.** An inline agent's whole contract is in the call, so these
- * rules can be certain rather than best-effort — the definition's own `required`
- * list is checkable, and so is whether the prompts and the declared variables agree.
- *
- * Three rules exist because the PLATFORM does something with what you wrote:
- *
- *  - `INLINE_AGENT_SCAFFOLD_MODEL` — the model the platform's own scaffold ships is
- *    stale, and v1's smoke check for this node type fails a flow that keeps it. A
- *    warning, not an error: it is a real model id, it just should not be a default
- *    nobody chose.
- *  - `INLINE_AGENT_UNREFERENCED_INPUT` — flow-v1 derives the deployed input list by
- *    scanning the PROMPTS for `$vars.*` references and only falls back to the
- *    authored `agentInputVariables` when that pre-pass did not run. So a declared
- *    input the prompts never mention is pruned deployed while arriving locally: a
- *    disagreement between rungs and the platform, which is the one class that has to
- *    be said out loud rather than left to a run.
- *  - `INLINE_AGENT_PROMPT_JSON_TEXT` — the platform returns `returns` as a typed
- *    object: it becomes the `agent.json` `outputSchema`, and the agent runtime ends
- *    a run with a structured call that fills exactly those fields. A prompt that
- *    ALSO asks for JSON text makes the model pack its whole answer, serialized, into
- *    one string field. See {@link jsonTextDirective}.
- */
-function checkInlineAgent(step, inputs, diags, opts = {}, ledger = newResourceIdLedger()) {
-    const at = (code, message, suggestion) => {
-        diags.push({ level: 'error', code, message, step, ...(suggestion ? { suggestion } : {}) });
-    };
-    const warn = (code, message) => {
-        diags.push({ level: 'warning', code, message, step });
-    };
-    const blank = (v) => v === undefined || v === null || (typeof v === 'string' && v.trim() === '');
-    // `memory` is authorable in this SDK and NOT authorable on the platform. The
-    // bundled `uipath.agent.autonomous@1.4` carries a `memory` handle added by
-    // #431; the tenant's own manifest for that node type declares only
-    // `escalation, context, tool, success, error`, and the registry index (4977
-    // entries, 2026-09-09) contains NO `uipath.agent.resource.memory.*` type at
-    // all — so both halves of what `memory` emits are unknown to the platform.
-    // `context` is not the alternative: those resources are knowledge INDEXES
-    // (`…context.index.<slug>.<guid>`), i.e. context grounding, not episodic memory.
-    //
-    // Compile succeeds and `uip maestro flow validate` then hard-refuses the edge:
-    //
-    //   [edges[edge_0].sourcePort] Edge references source handle "memory" on node
-    //   "triage", but the current manifest for "uipath.agent.autonomous" does not
-    //   declare that handle … Retry: RetryWillNotFix
-    //
-    // An artifact that compiles and can never validate is the worst of the two
-    // failures, so this is said here — before the emit — rather than left to a rung.
-    // It is an ERROR because there is no spelling that works today, and `--no-check`
-    // remains the escape for a tenant whose manifest does declare the handle.
-    if (inputs?.memory !== undefined) {
-        at('AGENT_MEMORY_NOT_AUTHORABLE', `Inline agent step "${step}" attaches \`memory\`, which the platform cannot resolve: the tenant's `
-            + `\`uipath.agent.autonomous\` manifest declares no \`memory\` handle (only escalation, context, tool, `
-            + `success, error) and the registry serves no \`uipath.agent.resource.memory.*\` node type. The flow `
-            + `compiles and then fails \`uip maestro flow validate\` as RetryWillNotFix. Drop \`memory\`; for `
-            + `retrieval over a knowledge source use a context index instead (\`tools\`/context grounding). `
-            + `Pass --no-check only on a tenant whose manifest does declare the handle.`);
-    }
-    // A context `query` is what the RUNTIME searches with, and it is not an
-    // expression slot. A plain string is the model-invoked `dynamic` variant: the
-    // text becomes the description the model reads before it writes its own query.
-    // An expression renders as the `static` variant instead, whose `value` the
-    // retriever is handed VERBATIM — there is no `$vars` scope inside the agent and
-    // nothing templates it once `uip agent refresh` has stripped the node, so the
-    // search runs on the literal text `=js:$vars…`. With the default `threshold: 0`
-    // it still returns chunks, so it reads as working while retrieving on nonsense.
-    // Refused rather than emitted until the argument-bound form is implemented
-    // (`{ variant: 'argument' }`, which the runtime resolves from agent state).
-    const contexts = inputs?.context === undefined ? []
-        : Array.isArray(inputs.context) ? inputs.context : [inputs.context];
-    for (const cx of contexts) {
-        if (cx?.query !== undefined && typeof cx.query !== 'string') {
-            at('AGENT_CONTEXT_QUERY_NOT_EXPRESSION', `Inline agent step "${step}" gives its context index "${cx.name ?? ''}" an EXPRESSION \`query\`. `
-                + `The runtime searches with that value literally — it is not evaluated inside the agent — so `
-                + `retrieval runs on the text of the expression and quietly returns unrelated chunks. Use a plain `
-                + `string: it becomes the guidance the model reads before writing its own query, which is what a `
-                + `run-dependent search needs.`);
-        }
-    }
-    // The index id is half of the resource node's TYPE
-    // (`…context.index.<slug>.<id>`), and the platform resolves the index by it.
-    // A blank, padded or non-GUID id builds a type no tenant serves, and nothing
-    // downstream says so: the flow compiles, merges and validates, and the agent
-    // runs ungrounded. So it is an error, not a warning. The id is tested as
-    // written, not trimmed, because serialize emits it as written.
-    for (const cx of contexts) {
-        const id = typeof cx?.id === 'string' ? cx.id : '';
-        if (!GUID_RE.test(id)) {
-            at('AGENT_CONTEXT_NO_ID', `Inline agent step "${step}" grounds on context index "${cx?.name ?? ''}" with `
-                + (id.trim() === '' ? 'no `id`'
-                    : GUID_RE.test(id.trim()) ? `\`id\` ${JSON.stringify(cx?.id)}, which has whitespace around the GUID`
-                        : `\`id\` ${JSON.stringify(cx?.id)}, which is not a GUID`) + '. '
-                + `The id is the index's key: it is the tail of the resource node's type and how the runtime finds `
-                + `the index, so without a real one the agent runs ungrounded and \`validate\` does not notice. `
-                + `\`uip solution resources list --kind Index --source remote --search "<name>"\` returns it as \`Key\`.`);
-        }
-    }
-    // An index outside the deployment folder needs its folder named. The resource
-    // file carries no `indexId`, so `indexName` + `folderPath` is the whole locator,
-    // and `@uipath/tool-agent`'s `createIndexBinding` leaves the folder off the
-    // binding when `folderPath` is empty. A WARNING, not an error: an index in the
-    // deployment folder resolves without it.
-    for (const cx of contexts) {
-        if (cx != null && cx.folderPath === undefined) {
-            warn('AGENT_CONTEXT_NO_FOLDER_PATH', `Inline agent step "${step}" grounds on context index "${cx.name ?? ''}" without a \`folderPath\`. `
-                + `The emitted resource carries no index id, so the folder is half of how the runtime finds the `
-                + `index, and the binding is written without one. Give the index's folder — `
-                + `\`uip solution resources list --kind Index --source remote --search "<name>"\` returns it.`);
-        }
-    }
-    // The definition's own `required`: systemPrompt, userPrompt, model — each with
-    // `minLength: 1`, so a blank string is as invalid as a missing key.
-    if (blank(inputs?.model)) {
-        at('INLINE_AGENT_NO_MODEL', `Inline agent step "${step}" has no \`model\`. The node's definition requires one (\`minLength: 1\`), so `
-            + `a flow without it does not validate. \`uip agent model list\` shows what the tenant offers.`, `model: 'gpt-5.4'`);
-    }
-    if (blank(inputs?.systemPrompt)) {
-        at('INLINE_AGENT_NO_SYSTEM_PROMPT', `Inline agent step "${step}" has no \`systemPrompt\`. The node's definition requires one `
-            + `(\`minLength: 1\`). It is where the agent is told what it is and what shape to answer in.`);
-    }
-    if (blank(inputs?.userPrompt)) {
-        at('INLINE_AGENT_NO_USER_PROMPT', `Inline agent step "${step}" has no \`userPrompt\`. The node's definition requires one `
-            + `(\`minLength: 1\`). It is the per-run request.`);
-    }
-    const model = typeof inputs?.model === 'string' ? inputs.model.trim() : '';
-    if (model === 'gpt-4o-2024-11-20') {
-        warn('INLINE_AGENT_SCAFFOLD_MODEL', `Inline agent step "${step}" uses \`gpt-4o-2024-11-20\` — the model the platform's own scaffold ships, `
-            + `and the one v1's smoke check for this node type FAILS a flow for keeping (it is the definition's `
-            + `\`inputDefaults.model\`, not a choice). Pick a current model: \`uip agent model list\`.`);
-    }
-    // Where each resource node sits (`nodeId`, `source`): decompile writes them
-    // for a node the canvas placed, and compile writes them as given. A blank or
-    // repeated id would make compile refuse the flow or overwrite another node,
-    // and a `source` that is not a uuid names a directory the platform does not
-    // expect (the agent's own `source` has the same rule).
-    const asList = (v) => (v === undefined ? [] : Array.isArray(v) ? v : [v]);
-    const placed = [
-        ...asList(inputs?.context).map((r) => ({ what: `context index "${r?.name ?? ''}"`, kind: 'Context', nodeId: r?.nodeId, source: r?.source })),
-        ...asList(inputs?.tools).map((r) => ({ what: `${r?.kind ?? ''} tool`, kind: 'Tool', nodeId: r?.nodeId, source: r?.source })),
-        ...asList(inputs?.escalation).map((r) => ({ what: `escalation "${r?.name ?? ''}"`, kind: 'Escalation', nodeId: r?.nodeId, source: r?.source })),
-    ];
-    // The ids compile derives for the resources with no `nodeId`: the n-th one of
-    // a kind gets `<step><Kind>`, then `<step><Kind>2`, ... An explicit id equal to
-    // one of them makes compile refuse the flow, or rename the derived node.
-    for (const kind of ['Context', 'Tool', 'Escalation']) {
-        const derived = placed.filter((r) => r.kind === kind && r.nodeId === undefined);
-        derived.forEach((r, n) => {
-            const id = derivedResourceNodeId(step, kind, n);
-            if (!ledger.taken.has(id))
-                ledger.taken.set(id, `the id compile derives for the ${r.what} of inline agent step "${step}"`);
-        });
-    }
-    /** Explicit `source` -> the resource on THIS agent that has it: two would write one resource.json. */
-    const sources = new Map();
-    for (const r of placed) {
-        if (r.nodeId !== undefined) {
-            const id = typeof r.nodeId === 'string' ? r.nodeId : '';
-            const other = ledger.explicit.get(id);
-            if (id.trim() === '') {
-                at('INLINE_AGENT_RESOURCE_NODE_ID', `Inline agent step "${step}" gives its ${r.what} the \`nodeId\` ${JSON.stringify(r.nodeId)}, which is `
-                    + `not a node id. Omit \`nodeId\` to derive one, or give the id the node has in the flow.`);
-            }
-            else if (other !== undefined) {
-                at('INLINE_AGENT_RESOURCE_NODE_ID', `Inline agent step "${step}" gives its ${r.what} the \`nodeId\` "${id}", which the ${other.what} `
-                    + `(on step "${other.step}") already has. Node ids are unique in a flow.`);
-            }
-            else {
-                ledger.explicit.set(id, { step, what: r.what });
-            }
-        }
-        if (r.source === undefined)
-            continue;
-        // Not trimmed: compile writes `source` as given, into `inputs.source` and the directory name.
-        if (!GUID_RE.test(String(r.source))) {
-            at('INLINE_AGENT_RESOURCE_SOURCE_NOT_GUID', `Inline agent step "${step}" gives its ${r.what} the \`source\` ${JSON.stringify(r.source)}, which is not `
-                + `a uuid${/^\s|\s$/.test(String(r.source)) ? ' (it has spaces around it)' : ''}. \`source\` is the resource's `
-                + `directory under the agent's own (\`resources/<source>/resource.json\`) and the node's \`inputs.source\`. `
-                + 'Omit it and one is derived from the flow id, the step and the resource.');
-            continue;
-        }
-        const key = String(r.source).toLowerCase();
-        const first = sources.get(key);
-        if (first !== undefined) {
-            at('INLINE_AGENT_RESOURCE_SOURCE_DUP', `Inline agent step "${step}" gives its ${first} and its ${r.what} the same \`source\` "${String(r.source)}". `
-                + 'Both would write `resources/<source>/resource.json` under this agent, and the second file would replace '
-                + 'the first. Give each resource its own `source`, or omit `source` to derive one.');
-        }
-        else {
-            sources.set(key, r.what);
-        }
-    }
-    if (typeof inputs?.source === 'string' && GUID_RE.test(inputs.source.trim())) {
-        const key = inputs.source.trim().toLowerCase();
-        const other = ledger.agentSources.get(key);
-        if (other !== undefined && other !== step) {
-            at('INLINE_AGENT_RESOURCE_SOURCE_DUP', `Inline agent steps "${other}" and "${step}" have the same \`source\` "${inputs.source}". Both would write `
-                + '`<source>/agent.json`, and the second file would replace the first. Give each agent its own `source`, '
-                + 'or omit it to derive one.');
-        }
-        else {
-            ledger.agentSources.set(key, step);
-        }
-    }
-    if (inputs?.source !== undefined && !GUID_RE.test(String(inputs.source).trim())) {
-        at('INLINE_AGENT_SOURCE_NOT_GUID', `Inline agent step "${step}"'s \`source\` is ${JSON.stringify(inputs.source)}, which is not a uuid. `
-            + `\`source\` is the agent's own DIRECTORY name, and the platform resolves its configuration at `
-            + `"<source>/agent.json" — a non-uuid name is not what the designer or the runtime expect. Omit it and `
-            + `one is derived from the flow id and step name (stable across recompiles).`);
-    }
-    if (inputs?.returns && Object.keys(inputs.returns).length === 0) {
-        warn('INLINE_AGENT_EMPTY_RETURNS', `Inline agent step "${step}" declares \`returns: {}\`. That is not "no output" — it falls back to the `
-            + `definition's default, \`{ content: 'string' }\`, which is the scaffold shape. Declare the fields the `
-            + `agent must return, or drop the key and read \`content\`.`);
-    }
-    // A prompt that asks for JSON TEXT while `returns` declares the fields. The
-    // platform already returns those fields as a typed object — `returns` is the
-    // agent.json `outputSchema`, and the runtime ends a run with a structured call
-    // that fills exactly those keys — so the extra directive does not shape the
-    // answer, it gets serialized INTO it: on 2026-09-23 a writer declaring
-    // `{ subject, body }` came back with `body` = '{"subject":…,"body":…}' in 3 of 3
-    // debug runs, and the flow mailed the JSON. `uip maestro flow validate` accepts
-    // the prompt (it never reads prompt meaning), so this is where it is said. An
-    // ERROR for the same reason `INLINE_AGENT_UNDECLARED_PLACEHOLDER` is one: the
-    // platform accepts the shape and the run still delivers the wrong value, and a
-    // warning is printed past while compile writes the .flow anyway. Only when
-    // `returns` is declared: with the `{ content }` default, JSON text in `content`
-    // may be exactly what the author reads back.
-    const returnKeys = Object.keys(inputs?.returns ?? {});
-    if (returnKeys.length) {
-        for (const field of ['systemPrompt', 'userPrompt']) {
-            const phrase = jsonTextDirective(String(inputs?.[field] ?? ''), returnKeys);
-            if (phrase === undefined)
-                continue;
-            const rewrite = `Return a result conforming to the output schema. `
-                + returnKeys.map((k) => `${k}: <what it holds>.`).join(' ');
-            at('INLINE_AGENT_PROMPT_JSON_TEXT', `Inline agent step "${step}"'s \`${field}\` tells the model to answer in JSON text ("${phrase}"), `
-                + `but \`returns\` already declares the answer: ${returnKeys.map((k) => `\`${k}\``).join(', ')}. `
-                + `The platform returns those fields as a typed object — \`returns\` becomes the agent.json `
-                + `\`outputSchema\`, and the agent runtime ends each run with a structured call that fills exactly `
-                + `those keys — so \`out('${step}', '${returnKeys[0]}')\` reads a value, not text to parse. Asking `
-                + `for JSON as well makes the model pack its whole answer, serialized, into one string field (for `
-                + `example a \`body\` that reads '{"subject":…,"body":…}'). Replace only that JSON instruction (keep the rest `
-                + `of the prompt) with one line per field, in the platform's own wording: "${rewrite}" Declare a field \`'object'\` or `
-                + `\`'array'\` if it should carry structure. \`uip maestro flow validate\` accepts this prompt, so `
-                + `nothing later catches it. If this is a false positive (the prompt only mentions JSON as data), `
-                + `compile with --no-check.`);
-        }
-    }
-    // The prompts-vs-variables agreement, in both directions. Both prompts are
-    // searched, because flow-v1's pre-pass scans both.
-    const prompts = `${String(inputs?.systemPrompt ?? '')}\n${String(inputs?.userPrompt ?? '')}`;
-    const placeholders = [...prompts.matchAll(/\{\{\s*input\.([A-Za-z_$][A-Za-z0-9_$]*)\s*\}\}/g)]
-        .map((m) => m[1]);
-    const declaredInputs = Object.keys(inputs?.inputs ?? {});
-    // Direction 1: a declared input no prompt references. The platform may prune it,
-    // in which case the agent receives nothing and the authored list sits unused.
-    const unreferenced = declaredInputs.filter((k) => !placeholders.includes(k));
-    if (declaredInputs.length && unreferenced.length === declaredInputs.length) {
-        warn('INLINE_AGENT_UNREFERENCED_INPUT', `Inline agent step "${step}" declares input(s) ${unreferenced.map((u) => `\`${u}\``).join(', ')} that `
-            + `neither prompt references as \`{{input.<name>}}\` — so NONE of them is referenced. Deployed, the `
-            + `authored list is not necessarily what the platform sends: flow-v1's `
-            + `\`preDeriveAgentInputDefinitions\` pre-pass builds the input list by scanning the node's prompts for `
-            + `variable references, merges what it finds with the authored list, and DROPS an entry no reference `
-            + `points at when its caller asks for pruning. A referenced input survives every path; an unreferenced `
-            + `one survives only some, and the failure mode is an agent that arrives with no arguments at all. `
-            + `Write \`{{input.${declaredInputs[0]}}}\` in a prompt — which is also how the agent gets told what it `
-            + `is looking at.`);
-    }
-    else if (unreferenced.length) {
-        warn('INLINE_AGENT_UNREFERENCED_INPUT', `Inline agent step "${step}" declares input(s) ${unreferenced.map((u) => `\`${u}\``).join(', ')} that `
-            + `neither prompt references as \`{{input.<name>}}\`. The platform may prune an unreferenced input, so `
-            + `it is not reliably sent — and an input the prompts never mention is one the agent cannot use anyway.`);
-    }
-    // Direction 2: a placeholder naming an input that does not exist. The compiler
-    // leaves it alone rather than deleting it, so it reaches the model as the literal
-    // text `{{input.x}}` — visible, but not what anyone meant.
-    const undeclared = [...new Set(placeholders.filter((p) => !declaredInputs.includes(p)))];
-    if (undeclared.length) {
-        at('INLINE_AGENT_UNDECLARED_PLACEHOLDER', `Inline agent step "${step}" references ${undeclared.map((u) => `\`{{input.${u}}}\``).join(', ')} in a `
-            + `prompt, but \`inputs\` declares ${declaredInputs.length ? declaredInputs.map((d) => `\`${d}\``).join(', ') : 'nothing'}. `
-            + `An unmatched placeholder is not substituted — it reaches the model as that literal text, and the `
-            + `value it was meant to carry never arrives.`, declaredInputs.length
-            ? `inputs: { ${undeclared[0]}: input('${undeclared[0]}'), … }`
-            : `inputs: { ${undeclared[0]}: input('${undeclared[0]}') }`);
-    }
-    // Direction 3: an input bound to a COMPUTED EXPRESSION rather than to one
-    // reference. The platform names each of an agent's arguments after the
-    // reference path it is bound to (the shell node's `agentInputVariables`), so
-    // an expression spanning zero or several references has no single argument —
-    // and therefore no name a `{{input.<x>}}` token could address. The compiler
-    // declares no argument for it, so its value does not reach the agent, and the
-    // placeholder reaches the model as literal text. An error rather than a
-    // warning, and for the same reason `INLINE_AGENT_UNDECLARED_PLACEHOLDER` is
-    // one: the value never arrives.
-    for (const [name, val] of Object.entries(inputs?.inputs ?? {})) {
-        if (!(val instanceof Expr) || val.literal)
-            continue;
-        if (flatNameOf(val.js) !== undefined)
-            continue;
-        if (!placeholders.includes(name))
-            continue;
-        at('INLINE_AGENT_COMPOSITE_INPUT', `Inline agent step "${step}"'s input \`${name}\` is bound to a computed expression `
-            + `(\`${val.js.length > 60 ? `${val.js.slice(0, 60)}…` : val.js}\`), and a prompt references it as `
-            + `\`{{input.${name}}}\`. The platform does not send the agent the names you declared: it names each `
-            + `argument after the REFERENCE PATH the input is bound to (\`$vars.a.output.b\` → \`a__output__b\`). `
-            + `A computed expression is not one reference, so it gets no argument: its value does not reach the `
-            + `agent, and the placeholder reaches the model as that literal text.`, `compute it in a script step first, then bind the step's output: `
-            + `.step('${name}Value', script({ code: 'return …;' })) … inputs: { ${name}: out('${name}Value') }`);
-    }
-    // A step id containing `__` makes the flat name AMBIGUOUS on the platform: the
-    // encoding joins path segments with `__` and v1's own inverse (`decodeFlatName`)
-    // documents that it round-trips only while ids "disallow `__`". A warning, not
-    // an error — the argument is still SENT and our token still matches it, so the
-    // agent works; what breaks is anything that decodes the name back to a path
-    // (the CLI's `hydrateInlineAgentInputs` reconcile, and the designer).
-    for (const [name, val] of Object.entries(inputs?.inputs ?? {})) {
-        if (!(val instanceof Expr) || val.literal)
-            continue;
-        const segments = flatNameSegmentsOf(val.js);
-        const offender = segments?.find((s) => s.includes(FLAT_SEP));
-        if (!offender)
-            continue;
-        warn('INLINE_AGENT_INPUT_NAME_AMBIGUOUS', `Inline agent step "${step}"'s input \`${name}\` reads \`${val.js}\`, whose path segment `
-            + `\`${offender}\` contains \`${FLAT_SEP}\`. The platform names the argument by joining the path's `
-            + `segments with \`${FLAT_SEP}\` (\`${segments.join(FLAT_SEP)}\`), so that name no longer says where `
-            + `the value came from — v1's own inverse round-trips only while ids avoid \`${FLAT_SEP}\`. The `
-            + `argument is still sent and the prompt still reads it; what breaks is anything decoding the name `
-            + `back to a path. Rename the step or variable to drop the double underscore.`);
-    }
-    // GUARDRAILS (Phase 4F). The node's definition types the input only as
-    // `array`, so a malformed entry deploys silently and either never trips or
-    // blocks every run — both invisible until production. The shapes below are
-    // Agent Builder's own discriminators.
-    const rails = inputs?.guardrails;
-    if (rails !== undefined) {
-        const ids = new Set();
-        rails.forEach((g, i) => {
-            const label = g?.name ? `"${g.name}"` : `guardrails[${i}]`;
-            if (!g || (g.$guardrailType !== 'custom' && g.$guardrailType !== 'builtInValidator')) {
-                at('GUARDRAIL_TYPE_UNKNOWN', `Inline agent step "${step}"'s ${label} has the $guardrailType `
-                    + `${JSON.stringify(g?.$guardrailType)}. Valid: 'custom' `
-                    + `(rules you author) or 'builtInValidator' (a platform validator).`);
-                return;
-            }
-            if (blank(g.id) || blank(g.name)) {
-                at('GUARDRAIL_INCOMPLETE', `Inline agent step "${step}"'s ${label} is missing ${blank(g.id) ? 'an id' : 'a name'} — `
-                    + `both are required by the agent schema (the id keys the rail, the name is what trips show).`);
-                return;
-            }
-            if (ids.has(g.id)) {
-                at('GUARDRAIL_DUP_ID', `Inline agent step "${step}" declares the guardrail id "${g.id}" twice — the second silently `
-                    + `shadows the first in Agent Builder's keyed storage.`);
-                return;
-            }
-            ids.add(g.id);
-            if (!Array.isArray(g.selector?.scopes) || g.selector.scopes.length === 0) {
-                at('GUARDRAIL_NO_SCOPE', `Inline agent step "${step}"'s guardrail "${g.name}" selects no scopes — it can never apply.`, `selector: { scopes: ['Agent'] }`);
-            }
-            const act = g.action?.$actionType;
-            if (act !== 'block' && act !== 'filter' && act !== 'log') {
-                at('GUARDRAIL_ACTION_UNKNOWN', `Inline agent step "${step}"'s guardrail "${g.name}" has the action ${JSON.stringify(act)}. `
-                    + `Valid: 'block', 'filter', 'log'.`);
-            }
-            if (g.$guardrailType === 'custom' && (!Array.isArray(g.rules) || g.rules.length === 0)) {
-                at('GUARDRAIL_NO_RULES', `Inline agent step "${step}"'s custom guardrail "${g.name}" has no rules — nothing can ever `
-                    + `trip it, so the action never fires.`, `rules: [{ $ruleType: 'always', applyTo: 'inputAndOutput' }]`);
-            }
-            if (g.$guardrailType === 'builtInValidator' && blank(g.validatorType)) {
-                at('GUARDRAIL_NO_VALIDATOR', `Inline agent step "${step}"'s guardrail "${g.name}" names no validatorType — the platform `
-                    + `cannot resolve which built-in validator to run.`);
-            }
-        });
-    }
-    // TOOLS and ESCALATION (card G16). Cheap identity checks only: a wrong KIND
-    // or a non-uuid KEY emits a node type the tenant has never heard of, which
-    // nothing downstream of the compiler can see — the resource is dropped from
-    // emitted graph, so no rung ever exercises it. Library resolution for connector
-    // tools happens at compile (where the library is), not here.
-    const toolRefs = inputs?.tools === undefined ? []
-        : Array.isArray(inputs.tools) ? inputs.tools : [inputs.tools];
-    const BUILTIN_TOOLS = ['analyzefiles', 'summarize', 'batchtransform'];
-    for (const t of toolRefs) {
-        const kind = t?.kind;
-        if (kind === 'builtin') {
-            if (!BUILTIN_TOOLS.includes(String(t.tool))) {
-                at('INLINE_AGENT_TOOL_UNKNOWN_BUILTIN', `Inline agent step "${step}" declares a builtin tool ${JSON.stringify(t.tool)}. `
-                    + `The platform ships exactly three: ${BUILTIN_TOOLS.map((b) => `'${b}'`).join(', ')} — the node type is a `
-                    + `fixed string, so any other name is a node the tenant has never heard of.`, `{ kind: 'builtin', tool: 'summarize' }`);
-            }
-        }
-        else if (kind === 'connector') {
-            const c = t;
-            if (blank(c.connector) || blank(c.operation)) {
-                at('INLINE_AGENT_TOOL_NO_OPERATION', `Inline agent step "${step}" declares a connector tool without ${blank(c.connector) ? 'a `connector`' : 'an `operation`'}. `
-                    + `Both name the curated-library entry the tool is resolved from — the same pair \`connector(…)\` takes.`, `{ kind: 'connector', connector: 'uipath-atlassian-jira', operation: 'create-issue' }`);
-            }
-            // A connector tool calls Integration Service on a CONNECTION, exactly as a
-            // connector step does — and before #867 there was no way to give it one, so
-            // the tool compiled with none anywhere (no binding, no resource.json row)
-            // and could only fail at run time. Both halves, as `registry prepare` writes them.
-            const labels = t;
-            const missing = ['connection', 'folder'].filter((k) => blank(labels[k]));
-            if (missing.length > 0) {
-                const key = blank(c.connector) ? '<connector-key>' : String(c.connector);
-                const op = blank(c.operation) ? '<operation>' : String(c.operation);
-                at('INLINE_AGENT_TOOL_CONNECTOR_NO_CONNECTION', `Inline agent step "${step}"'s connector tool "${key}/${op}" has no ${missing.map((m) => `\`${m}\``).join(' or ')}. `
-                    + `The tool calls Integration Service on a tenant connection: without one the agent's tool has no `
-                    + `connection binding, its resource.json carries none, and the solution's Resources never list it. `
-                    + `Name the bindings.json labels the same way \`connector()\` takes them — \`${prepareCommand(key, op)}\` `
-                    + `finds the connection and writes both entries.`, `{ kind: 'connector', connector: '${key}', operation: '${op}', connection: '<connection label>', folder: '<folder label>' }`);
-            }
-            else {
-                checkBindingLabels(`Inline agent step "${step}"'s connector tool`, labels, opts, (code, message) => at(code, message), blank(c.connector) ? undefined : { key: String(c.connector), ...(blank(c.operation) ? {} : { action: String(c.operation) }) });
-            }
-        }
-        else if (kind === 'ixp') {
-            const x = t;
-            if (blank(x.projectId) || !GUID_RE.test(String(x.projectId).trim())) {
-                at('INLINE_AGENT_TOOL_IXP_PROJECT_NOT_GUID', `Inline agent step "${step}"'s IxP tool has \`projectId\` ${JSON.stringify(x.projectId)}, which is not a uuid. `
-                    + `It is the node type's tail (uipath.agent.resource.tool.ixp.<slug>.<projectId>), so a wrong one emits a `
-                    + `node type the tenant cannot resolve. Find it: uip maestro flow registry pull --force && `
-                    + `uip maestro flow registry search -f "type:startsWith=uipath.agent.resource.tool.ixp".`);
-            }
-            if (blank(x.name)) {
-                at('INLINE_AGENT_TOOL_IXP_NO_NAME', `Inline agent step "${step}"'s IxP tool needs a \`name\` — the project's display name, which the definition `
-                    + `carries as both its label and \`inputDefaults.name\`.`);
-            }
-        }
-        else if (kind === 'process' || kind === 'agent' || kind === 'api' || kind === 'flow'
-            || kind === 'maestro' || kind === 'function') {
-            const p = t;
-            if (blank(p.key) || !GUID_RE.test(String(p.key).trim())) {
-                at('INLINE_AGENT_TOOL_KEY_NOT_GUID', `Inline agent step "${step}"'s '${String(kind)}' tool has \`key\` ${JSON.stringify(p.key)}, which is not a uuid. `
-                    + `The key IS the node type's tail (uipath.agent.resource.tool.…<key>), so a wrong one emits a node type `
-                    + `the tenant cannot resolve. Find it: uip maestro flow registry search "uipath.agent.resource.tool".`);
-            }
-            if (blank(p.name) || blank(p.folderPath)) {
-                at('INLINE_AGENT_TOOL_NO_RESOURCE_ID', `Inline agent step "${step}"'s '${String(kind)}' tool needs both \`name\` and \`folderPath\` — they form the `
-                    + `binding's resourceKey ("<folderPath>.<name>"), which is how the deployed flow finds the resource.`);
-            }
-        }
-        else if (kind === 'mcp') {
-            const m = t;
-            if (blank(m.name) || blank(m.key) || !GUID_RE.test(String(m.key).trim())) {
-                at('INLINE_AGENT_TOOL_MCP_INCOMPLETE', `Inline agent step "${step}"'s MCP tool needs a \`name\` and a uuid \`key\` — the node type is minted `
-                    + `from them (uipath.agent.resource.tool.mcp.<name>.<key>) and the key is the reference the runtime `
-                    + `resolves.`);
-            }
-        }
-        else if (kind === 'a2a') {
-            const a = t;
-            if (blank(a.name) || blank(a.key) || !GUID_RE.test(String(a.key).trim()) || blank(a.slug)) {
-                at('INLINE_AGENT_TOOL_A2A_INCOMPLETE', `Inline agent step "${step}"'s remote-A2A tool needs \`name\`, a uuid \`key\`, and \`slug\` — the node `
-                    + `type is minted from name+key, and the runtime resolves the remote agent by slug (the platform's own `
-                    + `mapper refuses a blank one).`);
-            }
-        }
-        else if (kind === 'clientside') {
-            if (blank(t.name)) {
-                at('INLINE_AGENT_TOOL_CLIENTSIDE_NO_NAME', `Inline agent step "${step}"'s client-side tool has no \`name\` — it is what the model calls, and the `
-                    + `calling application dispatches on it.`);
-            }
-        }
-        else if (kind === 'httpRequest') {
-            const h = t;
-            const m = h.method === undefined ? undefined : String(h.method).toUpperCase();
-            if (m !== undefined && !['GET', 'POST', 'PUT', 'PATCH', 'DELETE'].includes(m)) {
-                at('INLINE_AGENT_TOOL_HTTP_METHOD', `Inline agent step "${step}"'s HTTP-request tool fixes the method to ${JSON.stringify(h.method)}. The `
-                    + `tool's contract allows GET, POST, PUT, PATCH, DELETE — anything else the runtime refuses at call time.`);
-            }
-        }
-        else {
-            at('INLINE_AGENT_TOOL_UNKNOWN_KIND', `Inline agent step "${step}" declares a tool with kind ${JSON.stringify(kind)}. Valid kinds: 'builtin', `
-                + `'connector', 'process', 'agent', 'api', 'flow', 'maestro', 'function', 'ixp', 'mcp', 'a2a', `
-                + `'clientside', 'httpRequest'.`);
-        }
-    }
-    const escalations = inputs?.escalation === undefined ? []
-        : Array.isArray(inputs.escalation) ? inputs.escalation : [inputs.escalation];
-    for (const e of escalations) {
-        if (blank(e?.name)) {
-            at('INLINE_AGENT_ESCALATION_NO_NAME', `Inline agent step "${step}" declares an escalation without a \`name\`. The node's definition requires one `
-                + `(\`minLength: 1\`).`);
-        }
-        if (e?.variant !== undefined && e.variant !== 'quick-form') {
-            at('INLINE_AGENT_ESCALATION_VARIANT', `Inline agent step "${step}"'s escalation names the variant ${JSON.stringify(e.variant)}. Valid: `
-                + `'quick-form' — or omit it for the app-backed default.`);
-            continue;
-        }
-        if (e?.variant === 'quick-form') {
-            // The form lives INLINE: an app would be emitted and ignored, and a form
-            // with nothing to fill in is a notification nobody can answer.
-            if (e.app !== undefined) {
-                at('INLINE_AGENT_ESCALATION_QUICKFORM_WITH_APP', `Inline agent step "${step}"'s quick-form escalation also names an app. The form lives in the flow — `
-                    + `drop \`app\`, or drop the variant for the app-backed escalation.`);
-            }
-            if (!Array.isArray(e.fields) || e.fields.length === 0) {
-                at('INLINE_AGENT_ESCALATION_NO_FIELDS', `Inline agent step "${step}"'s quick-form escalation declares no \`fields\` — the reviewer gets an `
-                    + `empty form.`);
-            }
-            for (const f of Array.isArray(e.fields) ? e.fields : []) {
-                if (!FORM_FIELD_TYPES.includes(String(f?.type))) {
-                    at('INLINE_AGENT_ESCALATION_FIELD_TYPE_UNKNOWN', `Inline agent step "${step}"'s quick-form escalation gives the field "${String(f?.id ?? '?')}" the type `
-                        + `${JSON.stringify(f?.type)}, ${formFieldTypeWhy(f?.type, `which the form does not recognize — it would `
-                            + `be published as a plain string`)}. Valid: ${validFormFieldTypesText()}.`, formFieldTypeHint(f?.type));
-                }
-                const optionsProblem = formFieldOptionsProblem(f);
-                if (optionsProblem !== undefined) {
-                    const message = `Inline agent step "${step}"'s quick-form escalation field "${String(f?.id ?? '?')}" `
-                        + `${formFieldOptionsWhy(optionsProblem, f?.type)}.`;
-                    if (optionsProblem === 'ignored')
-                        warn('INLINE_AGENT_ESCALATION_FIELD_OPTIONS_IGNORED', message);
-                    else {
-                        at('INLINE_AGENT_ESCALATION_FIELD_OPTIONS', message, `options: [{ id: 'opt-1', value: 'high', label: 'High' }, { id: 'opt-2', value: 'low', label: 'Low' }]`);
-                    }
-                }
-                for (const problem of formFieldSettingProblems(f)) {
-                    at('INLINE_AGENT_ESCALATION_FIELD_SETTING_INVALID', `Inline agent step "${step}"'s quick-form escalation gives the field "${String(f?.id ?? '?')}" `
-                        + `${problem}. The platform refuses the form.`);
-                }
-            }
-            continue;
-        }
-        if (e?.fields !== undefined) {
-            at('INLINE_AGENT_ESCALATION_APP_WITH_FIELDS', `Inline agent step "${step}"'s escalation declares inline \`fields\`, but its form belongs to the deployed `
-                + `app. Use variant: 'quick-form' for an inline form.`);
-        }
-        if (blank(e?.app?.key) || blank(e?.app?.name)) {
-            at('INLINE_AGENT_ESCALATION_NO_APP', `Inline agent step "${step}"'s escalation needs \`app.key\` and \`app.name\` — the deployed Action Center app `
-                + `that carries the review task. An escalation with no app is a task nobody can open.`);
-        }
-        else if (!GUID_RE.test(String(e.app.key).trim())) {
-            at('INLINE_AGENT_ESCALATION_APP_KEY_NOT_GUID', `Inline agent step "${step}"'s escalation \`app.key\` is ${JSON.stringify(e.app.key)}, which is not a uuid. `
-                + `It is the app's own key on the tenant, not its name.`);
-        }
-    }
-    // MEMORY (Phase 5A): identity is required — the node type is minted from it.
-    const mem = inputs?.memory;
-    if (mem !== undefined) {
-        if (blank(mem.name) || blank(mem.id)) {
-            at('INLINE_AGENT_MEMORY_INCOMPLETE', `Inline agent step "${step}"'s memory needs both \`name\` and \`id\` — the node type is minted from them `
-                + `(uipath.agent.resource.memory.<name>.<id>) and the runtime resolves the memory by id.`);
-        }
-        else if (!GUID_RE.test(String(mem.id).trim())) {
-            at('INLINE_AGENT_MEMORY_ID_NOT_GUID', `Inline agent step "${step}"'s memory \`id\` is ${JSON.stringify(mem.id)}, which is not a uuid. It is the `
-                + `memory's own id on the tenant, not its name.`);
-        }
-    }
-}
-/**
- * A read of an inline agent's output: `out('<step>', '<field>')`.
- *
- * Stricter than the published families' equivalent, and it can afford to be: the
- * declared `returns` IS the contract (there is no tenant to disagree with), and it
- * is what any runner has to coerce the model's completion to: build
- * `{ <declared keys> }` and put the raw completion in the first one if the model
- * ignored the shape. So a read outside the set is undefined by construction, not
- * merely probably.
- */
-function checkInlineAgentRead(name, field, rest, spec, step, diags) {
-    if (field === undefined)
-        return;
-    if (field === 'error')
-        return;
-    if (field !== 'output') {
-        diags.push({
-            level: 'error',
-            code: 'INLINE_AGENT_READ_NOT_OUTPUT',
-            message: `Inline agent "${name}" publishes its answer under "output", but "$vars.${name}.${field}" (read in `
-                + `"${step}") asks for "${field}", which is undefined at run time.`,
-            step,
-            suggestion: `out('${name}', '<field>')`,
-        });
-        return;
-    }
-    // The default when `returns` is omitted is the definition's own.
-    const declared = spec.returns && Object.keys(spec.returns).length
-        ? Object.keys(spec.returns)
-        : ['content'];
-    const wanted = (rest ?? '').replace(/^\./, '').split('.')[0];
-    if (!wanted)
-        return;
-    if (declared.includes(wanted))
-        return;
-    const nearest = nearestName(wanted, declared);
-    diags.push({
-        level: 'error',
-        code: 'INLINE_AGENT_READ_UNKNOWN_FIELD',
-        message: `Inline agent "${name}" declares no output "${wanted}" (read as "$vars.${name}.output.${wanted}" in `
-            + `"${step}"). Its \`returns\` names: ${declared.join(', ')}`
-            + `${spec.returns && Object.keys(spec.returns).length ? '' : ' (the definition\'s default, because the step declares no `returns`)'}`
-            + `. Unlike a published agent's, this contract is yours — the node's \`agentOutputVariables\` are these `
-            + `names, and the engine coerces the model's completion to exactly them, so a read outside the set is `
-            + `undefined by construction.`,
-        step,
-        ...(nearest ? { suggestion: `out('${name}', '${nearest}')` } : {}),
-    });
-}
 /**
  * The five forbidden inputs on an IxP node. They belonged to a prior schema and
  * v1's own authoring reference calls them "the most common training-data-recall
@@ -3749,7 +2726,7 @@ function registeredKind(spec) {
  * which serialize enforces (#942) and the type's tests pin; an author cannot
  * cause the gap, so there is no author diagnostic to report.
  */
-function checkRegisteredStep(entry, s, exprs, errorSource, opts, diags, typeOf, triggerId, carried) {
+function checkRegisteredStep(entry, s, exprs, errorSource, opts, diags, typeOf, triggerId, ledger, carried) {
     const spec = s.spec;
     /** The step's node-local rules and expressions, as `impl` defines them. */
     const runRules = (impl, version = impl.version, carriedDef) => {
@@ -3764,7 +2741,25 @@ function checkRegisteredStep(entry, s, exprs, errorSource, opts, diags, typeOf,
                 return name ? { name, type: typeOf.get(name) } : undefined;
             },
             options: opts,
-            bindingLabels: (where, labels, use) => checkBindingLabels(where, labels, opts, (code, message) => diags.push({ level: 'error', code, step: s.name, message }), undefined, use),
+            bindingLabels: (where, labels, use, target) => checkBindingLabels(where, labels, opts, (code, message) => diags.push({ level: 'error', code, step: s.name, message }), target, use),
+            resources: {
+                derivedNodeId: (id, what) => { if (!ledger.taken.has(id))
+                    ledger.taken.set(id, what); },
+                claimNodeId: (id, what) => {
+                    const other = ledger.explicit.get(id);
+                    if (other === undefined)
+                        ledger.explicit.set(id, { step: s.name, what });
+                    return other;
+                },
+                claimFolder: (source) => {
+                    const key = source.toLowerCase();
+                    const other = ledger.agentSources.get(key);
+                    if (other !== undefined && other !== s.name)
+                        return other;
+                    ledger.agentSources.set(key, s.name);
+                    return undefined;
+                },
+            },
         };
         impl.check?.(spec, ctx);
         for (const site of impl.expressions(spec)) {
@@ -3901,10 +2896,11 @@ function collectActionExprs(s, out, errorSource) {
  *  - a bundled family by its bundled definition (`bundledActionNodeType` +
  *    `bundledDefinition`, #1011: `documentClassify` was missing from the old
  *    list although `uipath.document.classify@1.0` sets the flag);
- *  - a per-tenant family (`rpaWorkflow`, `apiWorkflow`, `agenticProcess`,
- *    `publishedFunction`, `agent`, `ixpExtract`) by the definition serialize
- *    synthesizes for it (`perCallDefinition`, #1040: `publishedFunction` was
- *    refused here although `publishedFunctionDef` sets the flag).
+ *  - a per-tenant family by the definition serialize synthesizes for it: a
+ *    registered one (the process family, `agent` among it) through its node
+ *    type's `errorPort`, which asks that definition, and `ixpExtract` through
+ *    `perCallDefinition` (#1040: `publishedFunction` was refused here although
+ *    `publishedFunctionDef` sets the flag).
  *
  * `publishedFunction`'s flag is measured, not assumed: on 2026-10-08 four
  * `flow debug` jobs on alpha/codereval called `acme-echo` with a non-string
@@ -4000,7 +2996,15 @@ placed, carried) {
         if (!placed)
             return;
         const { impl } = placed;
-        if (impl.definition === 'per-tenant') {
+        if (impl.definition === 'per-tenant' && placed.carried !== undefined) {
+            // At a carried version the carried definition answers, as serialize asks
+            // it: the type's declaration covers only the versions it registers.
+            if (!definitionHasErrorPort(placed.carried)) {
+                diags.push({ level: 'error', code: 'ONERROR_NO_ERROR_PORT', message: typedNoErrorPortMessage(step.name, impl.kind, placed.carried), step: step.name });
+                return;
+            }
+        }
+        else if (impl.definition === 'per-tenant') {
             const port = typeof impl.errorPort === 'function' ? impl.errorPort(spec) : impl.errorPort === true;
             if (!port) {
                 diags.push({
@@ -4034,7 +3038,7 @@ placed, carried) {
     // a bundled one does: it is the definition serialize will emit.
     const pinned = step.options?.version;
     const bundledDef = bundledType
-        ? bundledDefinition(bundledType, actionVersion(spec, pinned)) ?? (pinned !== undefined ? carried?.(bundledType, pinned) : undefined)
+        ? bundledDefinition(bundledType, pinned) ?? (pinned !== undefined ? carried?.(bundledType, pinned) : undefined)
         : undefined;
     // A per-tenant family: ask the definition serialize synthesizes for it (#1040).
     let perCallDef;