@uipath/maestro-builder-sdk 6.32.7 → 6.33.0

package/dist/case/decompile.js

@@ -3,6 +3,7 @@ import { tsLiteral, tsNumber } from '../core/ts-literal.js';
 import { CASE_FORMAT_PROFILE, CASE_SCHEMA_VERSIONS } from './format-profile.js';
 import { preserveSchemaVersion } from '../schema-version.js';
 import { ownEntry } from '../core/own-entry.js';
+import { isUnrestorableSlotId } from './preserve.js';
 const TASK_KIND_METHOD = {
     process: 'process',
     agent: 'agent',
@@ -932,6 +933,8 @@ function slaIdentity(sla) {
  *    has that id.
  *  - empty collections — there is nothing to align.
  *  - `nodeOrder` with fewer than two ids — ordering one node is identity.
+ *  - an `inputs` / `outputs` slot id copied verbatim from its name; the
+ *    serializer will not restore it, and the minted id replaces it.
  *
  * Everything else stays. A designer document orders stages before its trigger,
  * carries ids no label seeding reproduces, and needs every one of them.
@@ -943,6 +946,11 @@ function prunePreservation(preservation, plan) {
             delete identities.id;
         if (identities.triggers?.length === 1 && identities.triggers[0]?.id === 'trigger_1')
             delete identities.triggers;
+        for (const lane of ['inputs', 'outputs']) {
+            const rows = identities.variables?.[lane];
+            if (Array.isArray(rows))
+                identities.variables[lane] = rows.filter((row) => !isUnrestorableSlotId(lane, row));
+        }
         for (const key of ['triggers', 'stages', 'caseExitRules', 'slaRules'])
             if (Array.isArray(identities[key]) && identities[key].length === 0)
                 delete identities[key];

package/dist/case/preserve.d.ts

@@ -1,5 +1,13 @@
 import type { BuiltCase } from './case-sdk.js';
 export type PreservedVariableLane = 'inputs' | 'outputs' | 'inputOutputs';
+/**
+ * A preserved `inputs[]` / `outputs[]` slot id copied verbatim from its name is
+ * the STRICT_FORMAL_ARG_ID defect, not an identity to keep; the minted id stands.
+ */
+export declare function isUnrestorableSlotId(lane: string, row: {
+    name: string;
+    id?: string;
+}): boolean;
 /** One platform-owned node retained at its original position in `nodes[]`. */
 export interface PreservedCaseNode {
     /** Original zero-based position in the top-level `nodes[]` array. */

package/dist/case/preserve.js

@@ -1,3 +1,10 @@
+/**
+ * A preserved `inputs[]` / `outputs[]` slot id copied verbatim from its name is
+ * the STRICT_FORMAL_ARG_ID defect, not an identity to keep; the minted id stands.
+ */
+export function isUnrestorableSlotId(lane, row) {
+    return lane !== 'inputOutputs' && typeof row.id === 'string' && row.id === row.name;
+}
 const preserved = new WeakMap();
 /** Attach decompiler-owned, non-authoring wire data to a built case. */
 export function preserveCaseJson(built, payload) {

package/dist/case/serialize.js

@@ -9,6 +9,7 @@
  * name) are resolved here to the generated ids.
  */
 import { IdGen } from './ids.js';
+import { isUnrestorableSlotId } from './preserve.js';
 import { buildConnectorInputs, nestConnectorBody, transportHttpMethod } from '../core/connector-inputs.js';
 import { EQUALS_EXPR_DIALECT } from '../core/connector-checks.js';
 import { bindingLabelRefusal } from '../core/binding-messages.js';
@@ -502,7 +503,11 @@ function applyPreservedIdentities(result, preservation) {
     takeSlas(metadata.slaRules, identities.slaRules);
     const variables = result.variables;
     for (const [lane, rows] of Object.entries(identities.variables ?? {}))
-        (rows ?? []).forEach((row) => take(variables[lane]?.find((candidate) => candidate.name === row.name), row.id));
+        (rows ?? []).forEach((row) => {
+            if (isUnrestorableSlotId(lane, row))
+                return;
+            take(variables[lane]?.find((candidate) => candidate.name === row.name), row.id);
+        });
     const replace = (value) => {
         if (replacements.has(value))
             return replacements.get(value);

package/dist/check.js

@@ -34,9 +34,29 @@ 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) {
+    const out = [];
+    for (const [id, { step, what }] of ledger.explicit) {
+        const other = ledger.taken.get(id);
+        if (other === undefined)
+            continue;
+        out.push({
+            level: 'error', code: 'INLINE_AGENT_RESOURCE_NODE_ID', step,
+            message: `Inline agent step "${step}" gives its ${what} the \`nodeId\` "${id}", which is already `
+                + `${other}. Node ids are unique in a flow, so compile cannot write both. Give the resource another id, `
+                + 'or omit `nodeId` to derive one.',
+        });
+    }
+    return out;
+}
 export function check(built, opts = {}) {
     let diags = [];
-    const uses = collectConnectionUses(() => { diags = checkFlow(built, [], opts); });
+    const ledger = newResourceIdLedger();
+    const uses = collectConnectionUses(() => { diags = checkFlow(built, [], opts, ledger); });
+    diags.push(...resourceNodeIdClashes(ledger));
     for (const { id, message } of connectionConnectorConflicts(uses, opts)) {
         diags.push({ level: 'error', code: 'CONNECTION_CONNECTOR_CONFLICT', step: id, message });
     }
@@ -87,7 +107,7 @@ function checkStepIds(stepNames, trigger, diags) {
  * to notice a flow that (transitively) calls itself before the serializer
  * recurses forever.
  */
-function checkFlow(built, ancestors, opts = {}) {
+function checkFlow(built, ancestors, opts = {}, ledger = newResourceIdLedger()) {
     const diags = [];
     if (!built.id)
         diags.push({ level: 'error', code: 'NO_ID', message: 'flow() requires an id.' });
@@ -516,7 +536,7 @@ function checkFlow(built, ancestors, opts = {}) {
                     checkAgent(s.name, s.spec.inputs, diags);
                 }
                 if (s.spec.kind === 'inlineAgent') {
-                    checkInlineAgent(s.name, s.spec.inputs, diags, opts);
+                    checkInlineAgent(s.name, s.spec.inputs, diags, opts, ledger);
                 }
                 {
                     const rule = OUTPUT_READ_RULES[s.spec.kind];
@@ -878,6 +898,15 @@ function checkFlow(built, ancestors, opts = {}) {
     }
     reportUnreachableHitlOutcomes(hitlChoiceNoPorts, exprs, diags);
     checkRegisteredFamilies(registeredSteps, unresolvedSteps, stepNames, diags);
+    // The ids this scope's other nodes get, for the file-wide nodeId check in `check`.
+    for (const n of stepNames)
+        if (!ledger.taken.has(n))
+            ledger.taken.set(n, `the id of step "${n}"`);
+    if (!ledger.taken.has(triggerId))
+        ledger.taken.set(triggerId, 'the id of the trigger');
+    for (const ep of built.entryPoints ?? [])
+        if (!ledger.taken.has(ep.id))
+            ledger.taken.set(ep.id, `the id of entry point "${ep.id}"`);
     // Entry points: unique roots with valid triggers, colliding with nothing.
     const epIds = new Set();
     for (const ep of built.entryPoints ?? []) {
@@ -1294,7 +1323,7 @@ function checkFlow(built, ancestors, opts = {}) {
     for (const [stepName, child] of subflowChildren) {
         if (ancestors.includes(child) || child === built)
             continue;
-        for (const d of checkFlow(child, [...ancestors, built], opts)) {
+        for (const d of checkFlow(child, [...ancestors, built], opts, ledger)) {
             diags.push({
                 ...d,
                 code: d.code,
@@ -3061,7 +3090,7 @@ export function jsonTextDirective(text, returnKeys) {
  *    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 = {}) {
+function checkInlineAgent(step, inputs, diags, opts = {}, ledger = newResourceIdLedger()) {
     const at = (code, message, suggestion) => {
         diags.push({ level: 'error', code, message, step, ...(suggestion ? { suggestion } : {}) });
     };
@@ -3168,6 +3197,79 @@ function checkInlineAgent(step, inputs, diags, opts = {}) {
             + `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 `

package/dist/core/actions.d.ts

@@ -1131,7 +1131,43 @@ export type BuiltinToolName = 'analyzefiles' | 'summarize' | 'batchtransform';
  * `tool.mcp.*`/`uipath.agent.resource.mcp.*` resolves to nothing on this tenant
  * (no MCP server exists to point at, so there is no definition to derive).
  */
-export type ToolRef = BuiltinToolRef | ConnectorToolRef | ProcessToolRef | IxpToolRef | McpToolRef | RemoteA2aToolRef | ClientSideToolRef | HttpRequestToolRef;
+export type ToolRef = (BuiltinToolRef | ConnectorToolRef | ProcessToolRef | IxpToolRef | McpToolRef | RemoteA2aToolRef | ClientSideToolRef | HttpRequestToolRef) & AgentResourcePlacement;
+/**
+ * Where one of an inline agent's resources (a context index, a tool, an
+ * escalation) sits in the `.flow`: the id of its own resource NODE and the
+ * directory that holds its `resource.json`.
+ *
+ * @remarks
+ * Omit both when you write a flow: compile derives them, so a recompile is not
+ * a diff. Decompile writes them only for a file whose resource node another
+ * tool placed (the canvas, `uip maestro flow node add`) under an id or directory
+ * compile would not derive, so a no-edit round trip keeps the node, its layout
+ * entry and its directory instead of replacing them.
+ *
+ * ```ts
+ * // decompiled from a canvas file that named the index's node `ctx_7f2a1b`
+ * context: [{
+ *   name: 'Example SOP Index', id: '11111111-2222-4333-8444-555555555555',
+ *   nodeId: 'ctx_7f2a1b', source: 'd84e2c17-6a3f-4c59-b0e2-7f1a9c5b3d28',
+ * }]
+ * ```
+ */
+export interface AgentResourcePlacement {
+    /**
+     * The resource node's id. Defaults to `<agent step>Context`, `<agent step>Tool`
+     * or `<agent step>Escalation`, numbered from 2 for a second resource of the
+     * same kind (`<agent step>Context2`). Compile writes it as given and refuses an
+     * id another node in the flow already has (`check`: `INLINE_AGENT_RESOURCE_NODE_ID`).
+     */
+    nodeId?: string;
+    /**
+     * The resource's directory id, a uuid: the node's `inputs.source` and the
+     * `id` of `<agent source>/resources/<source>/resource.json`. Defaults to one
+     * derived from the flow id, the agent step and the resource, so a given flow
+     * emits the same uuid every time.
+     */
+    source?: string;
+}
 /**
  * An MCP server the agent may call tools on. The node type is minted from the
  * server's name and key exactly as the platform's own mapper does
@@ -1398,9 +1434,9 @@ export interface IxpToolRef {
 /**
  * One escalation an inline agent may raise — an Action Center app task a human
  * completes (the `coded-action-app` variant, the one this tenant's registry
- * serves).
+ * serves), placed in the flow by {@link AgentResourcePlacement}.
  */
-export interface EscalationRef {
+export interface EscalationRef extends AgentResourcePlacement {
     /** The escalation's name — required by the definition (`minLength: 1`). */
     name: string;
     /** When the agent should escalate — what a reviewer sees as the reason. */
@@ -1463,13 +1499,14 @@ export interface EscalationRef {
     labels?: string[];
 }
 /**
- * One Context Grounding index an inline agent is grounded on.
+ * One Context Grounding index an inline agent is grounded on, placed in the
+ * flow by {@link AgentResourcePlacement}.
  *
  * @remarks
  * The optional fields mirror the platform's own `inputDefaults` for an index
  * resource, so omitting them emits exactly what the designer would.
  */
-export interface ContextIndexRef {
+export interface ContextIndexRef extends AgentResourcePlacement {
     /** The index's display name on the tenant, e.g. `'Billing Dispute SOP Index'`. */
     name: string;
     /**
@@ -1496,6 +1533,11 @@ export interface ContextIndexRef {
     threshold?: number;
     /** Restrict to one file type; `'All'` (the platform's default) or e.g. `'pdf'`. */
     fileExtension?: string;
+    /**
+     * The resource node's label on the canvas. Defaults to `name`. Only the
+     * canvas shows it; the index is found by `name` and `id`.
+     */
+    label?: string;
 }
 /**
  * Every action kind, keyed by kind, to the body of its spec — the arm's fields

package/dist/core/agent-resource-identity.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The identity compile derives for an inline agent's resource node when the
+ * author gives none: its node id and its resource directory (`inputs.source`).
+ *
+ * Serialize uses these to name what it emits. Decompile uses the same functions
+ * to decide whether a file's resource node carries the identity compile would
+ * derive anyway; when it does not (the canvas or the CLI placed the node), the
+ * decompiled source spells it out as `nodeId` / `source`
+ * (`AgentResourcePlacement`). One definition for both directions keeps
+ * them inverses: a second copy in decompile would drift from serialize's.
+ */
+import type { ToolRef } from './actions.js';
+/** The resource handles whose nodes compile names after the agent step. */
+export type AgentResourceKind = 'Context' | 'Tool' | 'Escalation' | 'Memory';
+/**
+ * The node id compile gives the `n`-th (0-based) resource of `kind` on agent
+ * step `agentStep` when no `nodeId` is set: `<step><Kind>`, then
+ * `<step><Kind>2`, `<step><Kind>3`, ... Characters a node id cannot hold become
+ * `_`, as compile's own id claim does. This assumes no other node already holds
+ * that id, which is the case for a flow compile wrote.
+ */
+export declare function derivedResourceNodeId(agentStep: string, kind: AgentResourceKind, n: number): string;
+/** The directory compile derives for a context index (`id` = the index id). */
+export declare function derivedContextSource(flowId: string, agentStep: string, indexId: string): string;
+/**
+ * What tells one tool on an agent from another for its derived directory: the
+ * built-in's name, the connector operation, the IxP project, the client-side or
+ * HTTP tool's name, else the resource key.
+ */
+export declare function toolResourceSeed(tr: ToolRef): string;
+/** The directory compile derives for a tool. */
+export declare function derivedToolSource(flowId: string, agentStep: string, tr: ToolRef): string;
+/** The directory compile derives for an escalation (`name` = the escalation's name). */
+export declare function derivedEscalationSource(flowId: string, agentStep: string, name: string): string;

package/dist/core/agent-resource-identity.js

@@ -0,0 +1,37 @@
+import { fnv1aX4Uuid } from './stable-id.js';
+/**
+ * The node id compile gives the `n`-th (0-based) resource of `kind` on agent
+ * step `agentStep` when no `nodeId` is set: `<step><Kind>`, then
+ * `<step><Kind>2`, `<step><Kind>3`, ... Characters a node id cannot hold become
+ * `_`, as compile's own id claim does. This assumes no other node already holds
+ * that id, which is the case for a flow compile wrote.
+ */
+export function derivedResourceNodeId(agentStep, kind, n) {
+    const base = `${agentStep}${kind}`.replace(/[^A-Za-z0-9_]/g, '_');
+    return n === 0 ? base : `${base}${n + 1}`;
+}
+/** The directory compile derives for a context index (`id` = the index id). */
+export function derivedContextSource(flowId, agentStep, indexId) {
+    return fnv1aX4Uuid(`${flowId}/${agentStep}/context/${indexId}`);
+}
+/**
+ * What tells one tool on an agent from another for its derived directory: the
+ * built-in's name, the connector operation, the IxP project, the client-side or
+ * HTTP tool's name, else the resource key.
+ */
+export function toolResourceSeed(tr) {
+    return tr.kind === 'builtin' ? tr.tool
+        : tr.kind === 'connector' ? `${tr.connector}.${tr.operation}`
+            : tr.kind === 'ixp' ? tr.projectId
+                : tr.kind === 'clientside' ? `clientside.${tr.name}`
+                    : tr.kind === 'httpRequest' ? `httprequest.${tr.name ?? 'default'}`
+                        : tr.key;
+}
+/** The directory compile derives for a tool. */
+export function derivedToolSource(flowId, agentStep, tr) {
+    return fnv1aX4Uuid(`${flowId}/${agentStep}/tool/${toolResourceSeed(tr)}`);
+}
+/** The directory compile derives for an escalation (`name` = the escalation's name). */
+export function derivedEscalationSource(flowId, agentStep, name) {
+    return fnv1aX4Uuid(`${flowId}/${agentStep}/escalation/${name}`);
+}

package/dist/decompile.js

@@ -38,6 +38,7 @@ import { commentText } from './core/comment-text.js';
 import { tsLiteral, tsNumber, tsText } from './core/ts-literal.js';
 import { ownEntry } from './core/own-entry.js';
 import { CONTEXT_INDEX_DEFAULTS, CONTEXT_INDEX_DEFAULT_FILE_EXTENSION, contextIndexSlug, parseContextIndexType, } from './core/context-index.js';
+import { derivedContextSource, derivedEscalationSource, derivedResourceNodeId, derivedToolSource, } from './core/agent-resource-identity.js';
 import { wireExprBody } from './core/wire-expr.js';
 import { hasExits } from './core/step-ports.js';
 import { parseIxpProjectType } from './core/actions.js';
@@ -107,6 +108,12 @@ let runWarned = new Set();
  * `.layout()` key, must use the id compile will produce, not the file's.
  */
 let runAbsorbed = new Map();
+/**
+ * The id the recompiled flow will have: the `flow(...)` argument decompile
+ * writes. Compile derives a resource's directory from it, so decompile needs it
+ * to tell a derived directory from one the file chose.
+ */
+let runFlowId = 'flow';
 /** `DecompileOptions.readSidecar` for the current run. */
 let runReadSidecar;
 function warnOnce(message) {
@@ -1160,20 +1167,45 @@ function emitAgentCluster(node, imp, inputNames, graph) {
     // spec order is this edge order: the first is `<agent><Kind>`, the n-th
     // `<agent><Kind><n>` (claimId's dedupe). Only the first memory is recovered,
     // so every further memory maps to `undefined`.
+    //
+    // When a port's nodes do not ALL carry those ids (the canvas or the CLI named
+    // them), every resource on the port is written with its own `nodeId`, and
+    // compile keeps the file's ids. All of them, not only the odd one: compile
+    // numbers the derived ids in order, so a derived id after an explicit one
+    // would come out one lower than the file's.
     // This reads the edges directly, not through `resource()`: it must see EVERY
     // artifact edge, including ones the spec does not carry, and it must not
     // account for any edge.
+    const keepIds = new Set();
     for (const [port, kind, emittedCount] of [
         ['context', 'Context', Infinity], ['tool', 'Tool', Infinity],
         ['escalation', 'Escalation', Infinity], ['memory', 'Memory', 1],
     ]) {
-        const base = `${node.id}${kind}`.replace(/[^A-Za-z0-9_]/g, '_');
-        (graph?.outEdges(node.id) ?? [])
+        const targets = (graph?.outEdges(node.id) ?? [])
             .filter((e) => e.sourcePort === port && graph.byId.has(e.targetNodeId))
-            .forEach((e, k) => {
-            runAbsorbed.set(e.targetNodeId, k >= emittedCount ? undefined : k === 0 ? base : `${base}${k + 1}`);
+            .map((e) => e.targetNodeId);
+        const keep = port !== 'memory'
+            && targets.some((id, k) => id !== derivedResourceNodeId(node.id, kind, k));
+        targets.forEach((id, k) => {
+            if (keep)
+                keepIds.add(id);
+            runAbsorbed.set(id, keep ? id : k >= emittedCount ? undefined : derivedResourceNodeId(node.id, kind, k));
         });
     }
+    /**
+     * The `nodeId` / `source` entries for resource node `r`: each only when it
+     * differs from what compile derives (`derivedSource`), so a flow compile
+     * wrote decompiles without them.
+     */
+    const placement = (r, derivedSource) => {
+        const source = unwrapSource((r.inputs ?? {}).source);
+        return [
+            ['nodeId', keepIds.has(r.id) ? tsLiteral(r.id) : undefined],
+            ['source', source !== undefined && source !== '' && source !== derivedSource ? tsLiteral(source) : undefined],
+        ];
+    };
+    /** A tool's options plus its placement; `seed` is the ref compile derives the tool's directory from. */
+    const toolOpts = (t, seed, entries) => opts([...entries, ...placement(t, derivedToolSource(runFlowId, node.id, seed))]);
     const rInputs = (n) => (n.inputs ?? {});
     const rPlain = (n, k) => {
         const raw = unwrapSource(rInputs(n)[k]);
@@ -1189,7 +1221,7 @@ function emitAgentCluster(node, imp, inputNames, graph) {
                     return undefined;
                 return objLit(Object.entries(props).map(([k, x]) => [k, tsLiteral(String(x?.type ?? 'string'))]));
             };
-            return opts([
+            return toolOpts(t, { kind: 'clientside', name: rPlain(t, 'name') ?? '' }, [
                 ['kind', tsLiteral('clientside')],
                 ['name', tsLiteral(rPlain(t, 'name') ?? '')],
                 ['description', rPlain(t, 'description') !== undefined ? tsLiteral(rPlain(t, 'description')) : undefined],
@@ -1206,7 +1238,8 @@ function emitAgentCluster(node, imp, inputNames, graph) {
                 const v = row.textValue;
                 return typeof v === 'number' ? String(v) : typeof v === 'string' ? tsLiteral(v) : JSON.stringify(v);
             };
-            return opts([
+            // `name` is not recovered, so compile derives the directory from the default.
+            return toolOpts(t, { kind: 'httpRequest' }, [
                 ['kind', tsLiteral('httpRequest')],
                 ['url', fixed('url')], ['method', fixed('method')],
                 ['headers', fixed('headers')], ['params', fixed('params')],
@@ -1214,7 +1247,7 @@ function emitAgentCluster(node, imp, inputNames, graph) {
             ]);
         }
         if (type.startsWith('uipath.agent.resource.tool.mcp.')) {
-            return opts([
+            return toolOpts(t, { kind: 'mcp', name: '', key: rPlain(t, 'referenceKey') ?? '' }, [
                 ['kind', tsLiteral('mcp')],
                 ['name', tsLiteral(rPlain(t, 'name') ?? '')],
                 ['key', tsLiteral(rPlain(t, 'referenceKey') ?? '')],
@@ -1225,7 +1258,7 @@ function emitAgentCluster(node, imp, inputNames, graph) {
             ]);
         }
         if (type.startsWith('uipath.agent.resource.tool.a2a.')) {
-            return opts([
+            return toolOpts(t, { kind: 'a2a', name: '', slug: '', key: rPlain(t, 'referenceKey') ?? '' }, [
                 ['kind', tsLiteral('a2a')],
                 ['name', tsLiteral(rPlain(t, 'name') ?? '')],
                 ['key', tsLiteral(rPlain(t, 'referenceKey') ?? '')],
@@ -1234,17 +1267,19 @@ function emitAgentCluster(node, imp, inputNames, graph) {
             ]);
         }
         if (type.startsWith('uipath.agent.resource.tool.builtin.')) {
-            return opts([
+            const tool = type.slice('uipath.agent.resource.tool.builtin.'.length);
+            return toolOpts(t, { kind: 'builtin', tool }, [
                 ['kind', tsLiteral('builtin')],
-                ['tool', tsLiteral(type.slice('uipath.agent.resource.tool.builtin.'.length))],
+                ['tool', tsLiteral(tool)],
                 ['description', rPlain(t, 'description') !== undefined ? tsLiteral(rPlain(t, 'description')) : undefined],
             ]);
         }
         if (type.startsWith('uipath.agent.resource.tool.ixp.')) {
             const tail = type.slice('uipath.agent.resource.tool.ixp.'.length);
-            return opts([
+            const projectId = tail.slice(tail.indexOf('.') + 1);
+            return toolOpts(t, { kind: 'ixp', name: '', projectId }, [
                 ['kind', tsLiteral('ixp')],
-                ['projectId', tsLiteral(tail.slice(tail.indexOf('.') + 1))],
+                ['projectId', tsLiteral(projectId)],
                 ['name', tsLiteral(rPlain(t, 'name') ?? '')],
             ]);
         }
@@ -1266,9 +1301,10 @@ function emitAgentCluster(node, imp, inputNames, graph) {
                 const row = values.find((v) => v.name === n);
                 return typeof row?.default === 'string' ? row.default : undefined;
             };
-            return opts([
+            const key = type.slice(ns[0].length);
+            return toolOpts(t, { kind: 'process', name: '', folderPath: '', key }, [
                 ['kind', tsLiteral(ns[1])],
-                ['key', tsLiteral(type.slice(ns[0].length))],
+                ['key', tsLiteral(key)],
                 ['name', tsLiteral(bound('name') ?? rPlain(t, 'name') ?? '')],
                 ['folderPath', tsLiteral(bound('folderPath') ?? '')],
             ]);
@@ -1277,6 +1313,9 @@ function emitAgentCluster(node, imp, inputNames, graph) {
     });
     const contextSrc = resource('context').map((c) => {
         const { name, id, folderPath, sidecar } = contextIndexIdentity(node, c, rPlain);
+        // Compile labels the node with `name`; a canvas rename is kept as `label`.
+        const label = typeof c.display?.label === 'string' && c.display.label !== '' && c.display.label !== name
+            ? c.display.label : undefined;
         return opts([
             ['name', tsLiteral(name)],
             ['id', tsLiteral(id)],
@@ -1284,6 +1323,8 @@ function emitAgentCluster(node, imp, inputNames, graph) {
             ['folderKey', rPlain(c, 'folderKey') !== undefined ? tsLiteral(rPlain(c, 'folderKey')) : undefined],
             // `query` and the retrieval settings, from resource.json or the node (#1183).
             ...contextIndexSettings(node, c, sidecar),
+            ['label', label !== undefined ? tsLiteral(label) : undefined],
+            ...placement(c, derivedContextSource(runFlowId, node.id, id)),
         ]);
     });
     const escalationSrc = resource('escalation').map((e) => {
@@ -1323,6 +1364,7 @@ function emitAgentCluster(node, imp, inputNames, graph) {
             ['taskTitle', typeof extra.taskTitle === 'string' && extra.taskTitle !== '' ? tsLiteral(extra.taskTitle) : undefined],
             // 'medium' is the platform default.
             ['priority', typeof extra.priority === 'string' && extra.priority !== 'medium' ? tsLiteral(extra.priority) : undefined],
+            ...placement(e, derivedEscalationSource(runFlowId, node.id, rPlain(e, 'name') ?? '')),
         ]);
     });
     const mem = resource('memory', 1)[0];
@@ -3249,6 +3291,7 @@ export function decompile(flow, options = {}) {
     runDefs = new Map();
     runRawManifests = [];
     runAbsorbed = new Map();
+    runFlowId = slugId(flow);
     for (const d of (flow.definitions ?? [])) {
         if (typeof d?.nodeType !== 'string')
             continue;