@uipath/flow-tool 1.201.0 → 1.202.0-preview.136

package/dist/packager-tool-nxx8naxv.js

@@ -0,0 +1,4234 @@
+import {
+  DEFAULT_INTERVAL_MS,
+  DEFAULT_TIMEOUT_MS,
+  pendingSecondsFor,
+  pendingStallInstructions
+} from "./packager-tool-tf3d2y8z.js";
+import {
+  package_default
+} from "./packager-tool-7b6tpg7y.js";
+import {
+  VALID_RESOURCE_TYPES
+} from "./packager-tool-27avrkyk.js";
+import {
+  evaluatorTypeAliases
+} from "./packager-tool-a1hbfmws.js";
+import {
+  registerRegistryCommand,
+  registerSharedDebugInstanceCommands,
+  registerSharedIncidentCommands,
+  registerSharedInstanceCommands,
+  registerSharedProcessCommands,
+  registerSharedProcessesCommands
+} from "./packager-tool-cdwpc9fh.js";
+import {
+  setAgentProjectMetadataReader
+} from "./packager-tool-v9psxdy5.js";
+import {
+  ATTACHMENT_INSTRUCTIONS,
+  ATTACHMENT_UPLOAD_INSTRUCTIONS,
+  OutputFormatter,
+  RESULTS,
+  ScreenLogger,
+  appendOption,
+  catchError,
+  createHiddenDeprecatedTenantOption,
+  extractErrorMessage,
+  extractErrorMessageSync,
+  instructionsFor,
+  isPreviewBuild,
+  logger,
+  mapPackageMetadataOptions,
+  parseAttachmentSpec,
+  processContext,
+  registerPackageMetadataOptions,
+  resolveAttachmentInputs,
+  splitPackagedName,
+  summarizePlatformBody,
+  trackShipSucceeded
+} from "./packager-tool-5qaxht3k.js";
+import {
+  getFileSystem
+} from "./packager-tool-0v3s8r01.js";
+import {
+  __require
+} from "./packager-tool-1yh8g550.js";
+
+// src/commands/binding.ts
+var BINDING_LIST_EXAMPLES = [
+  {
+    Description: "List all bindings in a flow file",
+    Command: "uip maestro flow binding list flow.json",
+    Output: {
+      Code: "BindingListSuccess",
+      Data: {
+        Bindings: [
+          {
+            id: "a1b2c3d4-0000-0000-0000-000000000001",
+            name: "InvoiceProcess",
+            resource: "process",
+            defaultValue: "InvoiceProcess"
+          }
+        ],
+        Count: 1
+      }
+    }
+  }
+];
+var BINDING_ADD_EXAMPLES = [
+  {
+    Description: "Add a process binding to a flow",
+    Command: 'uip maestro flow binding add flow.json "Invoice" process "InvoiceProcess" --property-attribute name',
+    Output: {
+      Code: "BindingAddSuccess",
+      Data: {
+        Binding: {
+          id: "a1b2c3d4-0000-0000-0000-000000000001",
+          name: "Invoice",
+          resource: "process",
+          defaultValue: "InvoiceProcess",
+          propertyAttribute: "name"
+        }
+      }
+    }
+  }
+];
+var BINDING_DELETE_EXAMPLES = [
+  {
+    Description: "Remove all bindings by resource key",
+    Command: "uip maestro flow binding remove flow.json a1b2c3d4-0000-0000-0000-000000000001",
+    Output: {
+      Code: "BindingRemoveSuccess",
+      Data: {
+        DeletedBindings: [
+          {
+            id: "a1b2c3d4-0000-0000-0000-000000000001",
+            name: "Invoice"
+          }
+        ],
+        Count: 1
+      }
+    }
+  }
+];
+var registerBindingCommand = (program) => {
+  const binding = program.command("binding").description("Manage bindings in a Flow file");
+  binding.command("list").description("List all bindings in a Flow file").argument("<file>", "Path to the .flow file").examples(BINDING_LIST_EXAMPLES).trackedAction(processContext, async (file) => {
+    const { listBindingsInFlow } = await import("./binding-service-dh91hw9e.js");
+    const [error, result] = await catchError(listBindingsInFlow(file));
+    if (error) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Error listing bindings",
+        Instructions: extractErrorMessageSync(error)
+      });
+      processContext.exit(1);
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "BindingListSuccess",
+      Data: {
+        Bindings: result.bindings,
+        Count: result.count
+      }
+    });
+  });
+  binding.command("add").description(`Add a binding to a Flow file.
+` + `Valid resource types: ${VALID_RESOURCE_TYPES.join(", ")}`).argument("<file>", "Path to the .flow file").argument("<name>", "Binding display name").argument("<resource>", "Resource type").argument("<default-value>", "Default value for the binding").option("--resource-key <key>", "Resource catalog identifier").option("--property-attribute <attr>", "Target node property (e.g., name, folderPath, connection)").option("--resource-sub-type <type>", "Resource sub-classification (e.g., Agent, Process)").examples(BINDING_ADD_EXAMPLES).trackedAction(processContext, async (file, name, resource, defaultValue, options) => {
+    const { addBindingToFlow } = await import("./binding-service-dh91hw9e.js");
+    const [error, result] = await catchError(addBindingToFlow(file, name, resource, defaultValue, {
+      resourceKey: options.resourceKey,
+      propertyAttribute: options.propertyAttribute,
+      resourceSubType: options.resourceSubType
+    }));
+    if (error) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Error adding binding",
+        Instructions: extractErrorMessageSync(error)
+      });
+      processContext.exit(1);
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "BindingAddSuccess",
+      Data: {
+        Binding: result.binding
+      }
+    });
+  });
+  binding.command("remove").description("Remove all bindings with a given resource key from a Flow file").argument("<file>", "Path to the .flow file").argument("<resource-key>", "Resource key of the bindings to remove").examples(BINDING_DELETE_EXAMPLES).trackedAction(processContext, async (file, resourceKey) => {
+    const { deleteBindingFromFlow } = await import("./binding-service-dh91hw9e.js");
+    const [error, result] = await catchError(deleteBindingFromFlow(file, resourceKey));
+    if (error) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Error deleting binding",
+        Instructions: extractErrorMessageSync(error)
+      });
+      processContext.exit(1);
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "BindingRemoveSuccess",
+      Data: {
+        DeletedBindings: result.deletedBindings,
+        Count: result.count
+      }
+    });
+  });
+};
+
+// src/commands/debug.ts
+function buildHttpFailureOutput(err) {
+  const stageLabel = err.stage ?? "request";
+  const where = `${err.method} ${err.endpoint}`;
+  const traceSuffix = err.parsedTraceId ? ` (traceId=${err.parsedTraceId})` : "";
+  const attemptSuffix = (err.attempts ?? 1) > 1 ? `, ${err.attempts} attempts` : "";
+  const Message = `Failed during ${stageLabel}: HTTP ${err.httpStatus} on ${where}${traceSuffix}${attemptSuffix}`;
+  const Instructions = pickInstructions(err);
+  const Context = {
+    httpStatus: err.httpStatus,
+    stage: err.stage,
+    endpoint: err.endpoint,
+    method: err.method
+  };
+  if (err.parsedErrorCode !== undefined) {
+    Context.errorCode = err.parsedErrorCode;
+  }
+  if (err.parsedRequestId !== undefined) {
+    Context.requestId = err.parsedRequestId;
+  }
+  if (err.parsedTraceId !== undefined) {
+    Context.traceId = err.parsedTraceId;
+  }
+  if (err.attempts !== undefined) {
+    Context.attempts = err.attempts;
+  }
+  const output = {
+    Result: RESULTS.Failure,
+    Message,
+    Instructions,
+    Context
+  };
+  const Retry = pickRetryHint(err);
+  if (Retry !== undefined) {
+    output.Retry = Retry;
+  }
+  return output;
+}
+function pickRetryHint(err) {
+  if (err.httpStatus < 500 || err.httpStatus >= 600) {
+    return;
+  }
+  return (err.attempts ?? 1) > 1 ? "RetryWillNotFix" : "RetryAfter30Seconds";
+}
+function pickInstructions(err) {
+  const isOpaque5xx = err.httpStatus >= 500 && err.httpStatus < 600 && (err.parsedErrorCode === undefined || err.parsedErrorCode === "0");
+  if (isOpaque5xx) {
+    const stage = err.stage ?? "request";
+    const traceIds = err.traceIds?.length ? err.traceIds : err.parsedTraceId ? [err.parsedTraceId] : [];
+    const traceHint = traceIds.length ? ` traceIds: ${traceIds.join(", ")}.` : "";
+    const escalationTraces = traceIds.length ? ` and traceIds: ${traceIds.join(", ")}` : "";
+    if ((err.attempts ?? 1) > 1) {
+      return `${err.method} ${err.endpoint} returned ${err.httpStatus} on all ${err.attempts} attempts ` + `during '${stage}', so the backend runtime is down rather than blipping. ` + `Do not re-run 'debug' — escalate to the owning service team with the endpoint${escalationTraces}. ` + `To keep working meanwhile, run the project instead of debugging it: ` + `'uip solution pack <solution-path> <out-dir>', 'uip solution publish <out-dir>/<name>.zip', ` + `'uip solution deploy run', then 'uip maestro flow process run'.`;
+    }
+    return `The backend returned an unstructured ${err.httpStatus} during '${stage}'.${traceHint} ` + `This is often transient — wait ~30s and retry once. If it fails again, capture the traceId ` + `and ${err.method} ${err.endpoint} and escalate to the owning service team.`;
+  }
+  if (err.httpStatus === 401 || err.httpStatus === 403) {
+    return `Authentication/authorization rejected by ${err.method} ${err.endpoint}. ` + `Run 'uip login' and verify the active tenant has access.`;
+  }
+  if (err.httpStatus === 404) {
+    const isStructured = err.parsedErrorMessage !== undefined || err.parsedErrorCode !== undefined;
+    if (!isStructured) {
+      const body = summarizePlatformBody(err.body);
+      const bodySuffix = body ? ` Platform response: "${body}".` : "";
+      return `${err.method} ${err.endpoint} returned 404 during '${err.stage ?? "request"}', ` + `but the response was not a structured Orchestrator error — the request likely ` + `did not reach the tenant. This usually means the organization or tenant in your ` + `login session is wrong or was renamed. Run 'uip login tenant list' to see the ` + `current tenant names, re-select with 'uip login tenant set <name>' (or re-run ` + `'uip login'), then retry. Do not create a new workspace or retry as-is — the ` + `resource likely exists under the current tenant name.${bodySuffix}`;
+    }
+    const detail2 = err.parsedErrorMessage ? ` Backend reported: "${err.parsedErrorMessage}".` : "";
+    return `${err.method} ${err.endpoint} returned 404 during '${err.stage ?? "request"}'. ` + `The target resource may not exist — verify upstream IDs (solutionId, instanceId) ` + `and re-run.${detail2}`;
+  }
+  const detail = err.parsedErrorMessage ? ` Backend reported: "${err.parsedErrorMessage}".` : "";
+  return `${err.method} ${err.endpoint} failed with HTTP ${err.httpStatus} during ` + `'${err.stage ?? "request"}'.${detail} Inspect the response body for details ` + `and retry once before reporting.`;
+}
+function summarizeIncidents(incidents) {
+  return incidents.map((inc) => {
+    const code = inc.errorCode ? `[${inc.errorCode}] ` : "";
+    const element = inc.elementId ? ` (element ${inc.elementId})` : "";
+    return `${code}${inc.errorMessage}${element}`;
+  });
+}
+function buildIncidentInstructions(incidents, instanceId) {
+  const lines = summarizeIncidents(incidents);
+  const first = incidents[0];
+  const traceHint = first?.traceId ? ` traceId=${first.traceId}.` : "";
+  const detailHint = `Run 'uip maestro flow debug-instance incidents ${instanceId}' for ` + `the full backend payload (incidentId, errorDetails, AI summary).`;
+  return `Incident(s):
+  - ${lines.join(`
+  - `)}
+${detailHint}${traceHint}`;
+}
+var CONVERSATIONAL_DEBUG_WARNING = "This flow, which starts on a conversation trigger, can only be debugged from a chat UI. " + `Debug it using the chat panel from either:
+` + "  1. Studio Web — open the debug URL printed once the solution uploads " + `(also 'Data.studioWebUrl' in the result).
+` + "  2. UiPath Maestro VS Code extension — open the flow and hit Debug.";
+async function projectStartsOnConversationTrigger(projectPath) {
+  const [error, found] = await catchError((async () => {
+    const { readFlowWorkflow, resolveProjectFlowFile } = await import("./flow-io-r318sjrw.js");
+    const { startsOnConversationTrigger } = await import("./debug-conversation-trigger-452frzyz.js");
+    const flowFilePath = await resolveProjectFlowFile(projectPath);
+    const { workflow } = await readFlowWorkflow(flowFilePath);
+    return startsOnConversationTrigger(workflow);
+  })());
+  if (error) {
+    logger.info(`Skipped the conversational pre-flight scan: ${error.message}`);
+    return false;
+  }
+  return found === true;
+}
+var FLOW_DEBUG_EXAMPLES = [
+  {
+    Description: "Debug a local flow project via Studio Web",
+    Command: "uip maestro flow debug ./my-flow-project",
+    Output: {
+      Code: "FlowDebug",
+      Data: {
+        jobKey: "b2c3d4e5-0000-0000-0000-000000000001",
+        instanceId: "c3d4e5f6-0000-0000-0000-000000000001",
+        runId: "d4e5f6a7-0000-0000-0000-000000000001",
+        finalStatus: "Completed",
+        solutionId: "e5f6a7b8-0000-0000-0000-000000000001",
+        studioWebUrl: "https://cloud.uipath.com/org/tenant/studio_/debug/e5f6a7b8",
+        elementExecutions: [
+          { elementId: "Node_1", status: "Completed" }
+        ]
+      }
+    }
+  },
+  {
+    Description: "Conversational flow (core.trigger.conversation) — uploaded to Studio Web and handed off, since only a chat UI can drive it. No debug session is started",
+    Command: "uip maestro flow debug ./my-chat-flow --open-in-browser",
+    Output: {
+      Code: "FlowDebugStudioWebHandoff",
+      Data: {
+        solutionId: "e5f6a7b8-0000-0000-0000-000000000001",
+        studioWebUrl: "https://cloud.uipath.com/org/studio_/designer/a1b2c3d4?solutionId=e5f6a7b8",
+        handedOff: true
+      }
+    }
+  },
+  {
+    Description: 'Faulted debug — emitted as a Result: "Failure" envelope (exit 1) with incident details (errorCode, errorMessage, elementId) inline on Data.incidents, so no follow-up command is needed',
+    Command: "uip maestro flow debug ./my-flow-project",
+    Output: {
+      Code: "FlowDebug",
+      Data: {
+        jobKey: "b2c3d4e5-0000-0000-0000-000000000001",
+        instanceId: "c3d4e5f6-0000-0000-0000-000000000001",
+        runId: "d4e5f6a7-0000-0000-0000-000000000001",
+        finalStatus: "Faulted",
+        incidents: [
+          {
+            incidentId: "inc-1",
+            elementId: "Node_3",
+            errorCode: "Process.UnhandledException",
+            errorMessage: "Object reference not set to an instance of an object."
+          }
+        ]
+      }
+    }
+  }
+];
+var LOGIN_INSTRUCTIONS = "Run 'uip login' and select an organization, tenant, and folder with Studio Web access, then retry.";
+var INPUT_INSTRUCTIONS = "Provide --inputs as a valid JSON object or a readable @file.json path.";
+var NUMBER_OPTION_INSTRUCTIONS = "Use a positive numeric value. Provide --poll-interval in milliseconds and --timeout in seconds.";
+var FOLDER_ID_INSTRUCTIONS = "Provide --folder-id as a positive integer (the Orchestrator folder Id, e.g. 12345).";
+var FOLDER_TARGETING_INSTRUCTIONS = "Pass at most one of --folder-id, --folder-key, or --folder-path. Use 'uip or folders list' to discover values.";
+var FOLDER_RESOLUTION_INSTRUCTIONS = "Provide a valid --folder-key (UUID) or --folder-path. Use 'uip or folders list' to confirm the key or path.";
+var FOLDER_RESOLUTION_NETWORK_INSTRUCTIONS = "The folder lookup itself failed (network / Orchestrator API). Re-authenticate with 'uip login', verify connectivity, and retry.";
+var DEBUG_FAILURE_INSTRUCTIONS = "Check that the flow project is valid, the selected folder is accessible, and Studio Web debug is available, then retry.";
+async function openInBrowserOrWarn(url) {
+  const [openError] = await catchError(async () => {
+    await getFileSystem().utils.open(url);
+  });
+  if (openError) {
+    OutputFormatter.log({
+      Warning: `Could not open the browser automatically: ${openError.message}`
+    });
+  }
+}
+function buildHandoffInstructions(studioWebUrl) {
+  return "This flow can only be driven from a chat UI, so no debug session was started. " + `Debug it using the chat panel from either:
+` + `  1. Studio Web — open ${studioWebUrl}.
+` + "  2. UiPath Maestro VS Code extension — open the flow and hit Debug.";
+}
+function isFolderInputError(err) {
+  if ("response" in err)
+    return false;
+  if (err.name === "FetchError")
+    return false;
+  return true;
+}
+function parsePositiveNumberOption(value, optionName) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return {
+      ok: false,
+      message: `${optionName} must be a positive number.`
+    };
+  }
+  return { ok: true, value: parsed };
+}
+function parsePositiveIntegerOption(value, optionName) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    return {
+      ok: false,
+      message: `${optionName} must be a positive integer.`
+    };
+  }
+  return { ok: true, value: parsed };
+}
+function registerDebugCommand(program) {
+  program.command("debug").description("Debug a flow project by uploading to Studio Web and running a debug session").argument("<project-path>", "Path to the flow project directory (must contain project.uiproj)").option("--folder-id <id>", "Orchestrator folder ID (OrganizationUnitId) as a positive integer. Mutually exclusive with --folder-key/--folder-path. Auto-detected if none are provided.").option("--folder-key <key>", "Orchestrator folder key (UUID). The CLI resolves it to the folder ID. Mutually exclusive with --folder-id/--folder-path.").option("--folder-path <path>", "Orchestrator folder path (e.g. 'Shared/Sub'). The CLI resolves it to the folder ID. Mutually exclusive with --folder-id/--folder-key.").option("--poll-interval <ms>", "Polling interval in milliseconds", "2000").option("--timeout <seconds>", "Maximum seconds to wait for debug completion").option("-i, --inputs <json>", "Input parameters as JSON string or @file.json").option("--attachment <name=path>", "Upload a file as a file-typed workflow input variable (repeatable). " + "Example: --attachment file1=./resume.pdf", appendOption, []).option("--open-in-browser", "Open the Studio Web URL in the browser once it is known.").option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).examples(FLOW_DEBUG_EXAMPLES).trackedAction(processContext, async (projectPath, options) => {
+    const { getLoginStatusAsync } = await import("./index-1kgxzh8x.js");
+    const isConversational = await projectStartsOnConversationTrigger(projectPath);
+    if (isConversational) {
+      OutputFormatter.log({
+        Warning: CONVERSATIONAL_DEBUG_WARNING
+      });
+      if (options.timeout !== undefined) {
+        OutputFormatter.log({
+          Warning: "--timeout has no effect here: the CLI uploads and hands off without polling a run."
+        });
+      }
+    }
+    let urlReported = false;
+    const [loginError, login] = await catchError(getLoginStatusAsync({
+      ensureTokenValidityMinutes: options.loginValidity
+    }));
+    if (loginError) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: loginError.message,
+        Instructions: LOGIN_INSTRUCTIONS
+      });
+      processContext.exit(1);
+      return;
+    }
+    const {
+      loginStatus,
+      baseUrl,
+      accessToken,
+      organizationId,
+      tenantId,
+      tenantName,
+      organizationUnitId,
+      organizationName
+    } = login;
+    if (loginStatus !== "Logged in" || !baseUrl) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Not logged in. Run 'uip login' first.",
+        Instructions: LOGIN_INSTRUCTIONS
+      });
+      processContext.exit(1);
+      return;
+    }
+    if (!organizationId) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Organization ID not available from login.",
+        Instructions: LOGIN_INSTRUCTIONS
+      });
+      processContext.exit(1);
+      return;
+    }
+    if (!tenantId) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Tenant ID not available from login.",
+        Instructions: LOGIN_INSTRUCTIONS
+      });
+      processContext.exit(1);
+      return;
+    }
+    if (!tenantName) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Tenant name not available from login.",
+        Instructions: LOGIN_INSTRUCTIONS
+      });
+      processContext.exit(1);
+      return;
+    }
+    if (!accessToken) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Access token not available from login.",
+        Instructions: LOGIN_INSTRUCTIONS
+      });
+      processContext.exit(1);
+      return;
+    }
+    if (!organizationName) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Organization name not available from login. Required for Studio Web debug.",
+        Instructions: LOGIN_INSTRUCTIONS
+      });
+      processContext.exit(1);
+      return;
+    }
+    const folderTargetingFlags = [
+      options.folderId !== undefined ? "--folder-id" : undefined,
+      options.folderKey !== undefined ? "--folder-key" : undefined,
+      options.folderPath !== undefined ? "--folder-path" : undefined
+    ].filter((flag) => flag !== undefined);
+    if (folderTargetingFlags.length > 1) {
+      OutputFormatter.error({
+        Result: RESULTS.ValidationError,
+        Message: `Cannot combine ${folderTargetingFlags.join(", ")}.`,
+        Instructions: FOLDER_TARGETING_INSTRUCTIONS
+      });
+      processContext.exit(3);
+      return;
+    }
+    let userProvidedFolderId;
+    if (options.folderId !== undefined) {
+      const parsed = parsePositiveIntegerOption(options.folderId, "--folder-id");
+      if (!parsed.ok) {
+        OutputFormatter.error({
+          Result: RESULTS.ValidationError,
+          Message: parsed.message,
+          Instructions: FOLDER_ID_INSTRUCTIONS
+        });
+        processContext.exit(3);
+        return;
+      }
+      userProvidedFolderId = parsed.value;
+    } else if (options.folderKey !== undefined || options.folderPath !== undefined) {
+      const { resolveFolder } = await import("./index-ev4mdg5y.js");
+      const [folderError, folder] = await catchError(resolveFolder({
+        folderKey: options.folderKey,
+        folderPath: options.folderPath
+      }, { loginValidity: options.loginValidity }));
+      if (folderError || !folder) {
+        const inputProblem = !folderError || isFolderInputError(folderError);
+        const message = folderError ? `Could not resolve folder: ${folderError.message}` : "Folder targeting requested but no folder resolved.";
+        OutputFormatter.error({
+          Result: inputProblem ? RESULTS.ValidationError : RESULTS.Failure,
+          Message: message,
+          Instructions: inputProblem ? FOLDER_RESOLUTION_INSTRUCTIONS : FOLDER_RESOLUTION_NETWORK_INSTRUCTIONS
+        });
+        processContext.exit(inputProblem ? 3 : 1);
+        return;
+      }
+      userProvidedFolderId = folder.id;
+      logger.info(`Resolved folder '${folder.path}' to ID ${folder.id} (key ${folder.key}).`);
+    }
+    const studioWebConfig = {
+      baseUrl,
+      organizationId,
+      tenantId,
+      tenantName,
+      authToken: accessToken,
+      organizationUnitId: userProvidedFolderId ?? organizationUnitId,
+      organizationName,
+      userProvidedFolderId
+    };
+    logger.info("Login verified successfully.");
+    logger.info(`  Organization: ${organizationName} (${organizationId})`);
+    logger.info(`  Tenant: ${tenantName} (${tenantId})`);
+    logger.info(`  Base URL: ${baseUrl}`);
+    const {
+      FlowDebugService,
+      InboundVoiceDebugError,
+      MissingSolutionWrapperError,
+      UnregisteredProjectError
+    } = await import("./flow-debug-service-tfbefas6.js");
+    const { MaestroHttpError } = await import("./debug-http-client-wd6xb8v4.js");
+    const {
+      buildPollTimeoutFailureOutput,
+      DebugPollTimeoutError,
+      isSuccessfulDebugStatus
+    } = await import("./debug-service-fvyexnb1.js");
+    const {
+      buildSolutionUploadFailureOutput,
+      isSolutionUploadHttpError
+    } = await import("./index-n33np76r.js");
+    const service = new FlowDebugService;
+    const parsedPollInterval = parsePositiveNumberOption(options.pollInterval || "2000", "--poll-interval");
+    if (!parsedPollInterval.ok) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: parsedPollInterval.message,
+        Instructions: NUMBER_OPTION_INSTRUCTIONS
+      });
+      processContext.exit(1);
+      return;
+    }
+    const pollInterval = parsedPollInterval.value;
+    let maxPolls;
+    if (options.timeout !== undefined) {
+      const parsedTimeout = parsePositiveNumberOption(options.timeout, "--timeout");
+      if (!parsedTimeout.ok) {
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          Message: parsedTimeout.message,
+          Instructions: NUMBER_OPTION_INSTRUCTIONS
+        });
+        processContext.exit(1);
+        return;
+      }
+      maxPolls = Math.max(1, Math.ceil(parsedTimeout.value * 1000 / pollInterval));
+    }
+    let inputs;
+    if (options.inputs) {
+      const { parseFlowInputs } = await import("./flow-api-wv8p8xbd.js");
+      const [parseError, parsed] = await catchError(parseFlowInputs(options.inputs));
+      if (parseError) {
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          Message: `Failed to parse inputs: ${parseError.message}`,
+          Instructions: INPUT_INSTRUCTIONS
+        });
+        processContext.exit(1);
+        return;
+      }
+      inputs = parsed;
+    }
+    const attachmentSpecs = options.attachment ?? [];
+    if (attachmentSpecs.length > 0) {
+      const [parseError, specs] = catchError(() => attachmentSpecs.map(parseAttachmentSpec));
+      if (parseError) {
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          Message: parseError.message,
+          Instructions: ATTACHMENT_INSTRUCTIONS
+        });
+        processContext.exit(1);
+        return;
+      }
+      const { uploadJobAttachment } = await import("./index-ev4mdg5y.js");
+      const [uploadError, resolved] = await catchError(resolveAttachmentInputs(specs, (bytes, fileName) => uploadJobAttachment(bytes, fileName, {
+        tenant: tenantName
+      })));
+      if (uploadError) {
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          Message: uploadError.message,
+          Instructions: ATTACHMENT_UPLOAD_INSTRUCTIONS
+        });
+        processContext.exit(1);
+        return;
+      }
+      inputs = inputs ?? {};
+      for (const { name, path, reference } of resolved) {
+        if (name in inputs) {
+          logger.warn(`--attachment '${name}' overrides the value provided in --inputs.`);
+        }
+        inputs[name] = reference;
+        logger.info(`Uploaded '${path}' as attachment ${reference.ID} (variable '${name}').`);
+      }
+    }
+    if (inputs !== undefined) {
+      logger.info(`Inputs: ${JSON.stringify(inputs)}`);
+    }
+    const debugOptions = {
+      inputs,
+      ...maxPolls === undefined ? {} : { maxPolls },
+      ...isConversational ? { uploadOnly: true } : {}
+    };
+    logger.info(`Starting Studio Web debug session for: ${projectPath}`);
+    const [executeError, result] = await catchError(service.executeProjectViaStudioWeb(projectPath, studioWebConfig, {
+      onStatusChange: (st, executions) => {
+        const completed = executions.filter((e) => e.status === "Completed").length;
+        const total = executions.length;
+        logger.info(`Status: ${st} (${completed}/${total} elements completed)`);
+        for (const exec of executions) {
+          const icon = exec.status === "Completed" ? "v" : exec.status === "InProgress" ? ">" : "-";
+          logger.info(`  ${icon} ${exec.elementId} [${exec.status}]`);
+        }
+      },
+      onIncident: (incidents2) => {
+        logger.warn(`Incidents: ${JSON.stringify(incidents2)}`);
+      },
+      onStudioWebUrl: (url) => {
+        if (options.openInBrowser !== true)
+          return;
+        if (urlReported)
+          return;
+        urlReported = true;
+        OutputFormatter.log({
+          Message: `Studio Web debug URL: ${url}`
+        });
+        openInBrowserOrWarn(url);
+      }
+    }, pollInterval, debugOptions));
+    if (executeError) {
+      if (executeError instanceof MissingSolutionWrapperError) {
+        OutputFormatter.error({
+          Result: RESULTS.ValidationError,
+          Message: executeError.message,
+          Instructions: executeError.instructions
+        });
+        processContext.exit(3);
+        return;
+      }
+      if (executeError instanceof InboundVoiceDebugError) {
+        OutputFormatter.error({
+          Result: RESULTS.ValidationError,
+          Message: executeError.message,
+          Instructions: executeError.instructions
+        });
+        processContext.exit(3);
+        return;
+      }
+      if (executeError instanceof UnregisteredProjectError) {
+        OutputFormatter.error({
+          Result: RESULTS.ValidationError,
+          Message: executeError.message,
+          Instructions: executeError.instructions
+        });
+        processContext.exit(3);
+        return;
+      }
+      if (executeError instanceof DebugPollTimeoutError) {
+        OutputFormatter.error(buildPollTimeoutFailureOutput(executeError, "uip maestro flow debug-instance incidents"));
+      } else if (executeError instanceof MaestroHttpError) {
+        OutputFormatter.error(buildHttpFailureOutput(executeError));
+      } else if (isSolutionUploadHttpError(executeError)) {
+        OutputFormatter.error(buildSolutionUploadFailureOutput(executeError, {
+          subject: "flow",
+          importCheckHint: "Run 'uip maestro flow validate' to confirm the project is well-formed."
+        }));
+      } else {
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          Message: executeError.message,
+          Instructions: DEBUG_FAILURE_INSTRUCTIONS
+        });
+      }
+      processContext.exit(1);
+      return;
+    }
+    if ("uploadedOnly" in result) {
+      OutputFormatter.success({
+        Result: RESULTS.Success,
+        Code: "FlowDebugStudioWebHandoff",
+        Data: {
+          solutionId: result.solutionId,
+          studioWebUrl: result.studioWebUrl,
+          handedOff: true
+        },
+        Instructions: buildHandoffInstructions(result.studioWebUrl)
+      }, { preserveDataKeys: true });
+      processContext.exit(0);
+      return;
+    }
+    const success = isSuccessfulDebugStatus(result.finalStatus);
+    const data = {
+      jobKey: result.jobKey,
+      instanceId: result.instanceId,
+      runId: result.runId,
+      folderKey: result.folderKey,
+      finalStatus: result.finalStatus,
+      solutionId: result.solutionId,
+      studioWebUrl: result.studioWebUrl,
+      elementExecutions: result.elementExecutions,
+      variables: result.variables,
+      variablesError: result.variablesError,
+      incidents: result.incidents
+    };
+    if (success) {
+      const instructions = result.variablesError ? `Debug completed with status: ${result.finalStatus}, but the output variables could not be read after ${result.variablesError.attempts} attempt(s): ${result.variablesError.message}. ` + `Data.variables is absent and Data.variablesError explains why — treat the outputs as UNKNOWN, not empty. ` + `Retry with 'uip maestro flow debug-instance variables ${result.instanceId}'.` : `Debug completed with status: ${result.finalStatus}`;
+      OutputFormatter.success({
+        Result: RESULTS.Success,
+        Code: "FlowDebug",
+        Data: data,
+        Instructions: instructions
+      }, { preserveDataKeys: true });
+      processContext.exit(0);
+      return;
+    }
+    const incidents = result.incidents ?? [];
+    const summary = summarizeIncidents(incidents);
+    const Message = incidents.length ? `Debug session ${result.finalStatus}. ${summary[0]}` : `Debug session ${result.finalStatus}. No incident details returned by PIMS.`;
+    const Instructions = incidents.length ? buildIncidentInstructions(incidents, result.instanceId) : `Run 'uip maestro flow debug-instance incidents ${result.instanceId}' to inspect the backend payload, then 'uip maestro flow incident summary' to confirm whether the process recorded a tenant-level incident.`;
+    const Context = {};
+    if (incidents[0]?.errorCode) {
+      Context.errorCode = incidents[0].errorCode;
+    }
+    if (incidents[0]?.traceId) {
+      Context.traceId = incidents[0].traceId;
+    }
+    OutputFormatter.error({
+      Result: RESULTS.Failure,
+      Code: "FlowDebug",
+      Message,
+      Instructions,
+      ...Object.keys(Context).length > 0 ? { Context } : {},
+      Data: data
+    });
+    processContext.exit(1);
+  });
+}
+// src/commands/debug-instances.ts
+var registerDebugInstancesCommand = (program) => {
+  registerSharedDebugInstanceCommands(program, {
+    toolLabel: "Flow"
+  });
+};
+
+// src/commands/edge.ts
+var EDGE_LIST_EXAMPLES = [
+  {
+    Description: "List all edges in a flow file",
+    Command: "uip maestro flow edge list flow.json",
+    Output: {
+      Code: "EdgeListSuccess",
+      Data: {
+        Edges: [
+          {
+            id: "edge_a1b2c3d4",
+            source: "Node_1",
+            target: "Node_2"
+          }
+        ],
+        Count: 1
+      }
+    }
+  }
+];
+var EDGE_ADD_EXAMPLES = [
+  {
+    Description: "Add an edge between two nodes in a flow",
+    Command: "uip maestro flow edge add flow.json Node_1 Node_2",
+    Output: {
+      Code: "EdgeAddSuccess",
+      Data: {
+        Edge: {
+          id: "edge_a1b2c3d4",
+          source: "Node_1",
+          target: "Node_2",
+          sourcePort: "output",
+          targetPort: "input"
+        }
+      }
+    }
+  },
+  {
+    Description: "Re-running with the same arguments is idempotent: returns the existing edge id with code EdgeAlreadyExists and a stderr warning.",
+    Command: "uip maestro flow edge add flow.json Node_1 Node_2",
+    Output: {
+      Code: "EdgeAlreadyExists",
+      Data: {
+        Edge: {
+          id: "edge_a1b2c3d4",
+          source: "Node_1",
+          target: "Node_2",
+          sourcePort: "output",
+          targetPort: "input"
+        }
+      }
+    }
+  }
+];
+var EDGE_DELETE_EXAMPLES = [
+  {
+    Description: "Delete an edge by ID",
+    Command: "uip maestro flow edge delete flow.json edge_a1b2c3d4",
+    Output: {
+      Code: "EdgeDeleteSuccess",
+      Data: {
+        DeletedEdge: {
+          id: "edge_a1b2c3d4",
+          source: "Node_1",
+          target: "Node_2"
+        }
+      }
+    }
+  }
+];
+var EDGE_REMOVE_EXAMPLES = [
+  {
+    Description: "Remove an edge by ID",
+    Command: "uip maestro flow edge remove flow.json edge_a1b2c3d4",
+    Output: {
+      Code: "EdgeRemoveSuccess",
+      Data: {
+        DeletedEdge: {
+          id: "edge_a1b2c3d4",
+          source: "Node_1",
+          target: "Node_2"
+        }
+      }
+    }
+  }
+];
+function getDeleteEdgeInstructions(file) {
+  return `Check that "${file}" exists and run 'uip maestro flow edge list ${file}' to find a valid edge ID, then retry.`;
+}
+async function runDeleteEdge(file, edgeId, code) {
+  const { deleteEdgeFromFlow } = await import("./edge-service-e77bndbe.js");
+  const normalizedEdgeId = edgeId.trim();
+  const [error, result] = await catchError(deleteEdgeFromFlow(file, normalizedEdgeId));
+  if (error) {
+    OutputFormatter.error({
+      Result: RESULTS.Failure,
+      Message: "Error deleting edge",
+      Instructions: getDeleteEdgeInstructions(file)
+    });
+    processContext.exit(1);
+    return;
+  }
+  OutputFormatter.success({
+    Result: RESULTS.Success,
+    Code: code,
+    Data: {
+      DeletedEdge: result.deletedEdge
+    }
+  });
+}
+var registerEdgeCommand = (program) => {
+  const edge = program.command("edge").description("Manage edges in a Flow file");
+  edge.command("list").description("List all edges in a Flow file").argument("<file>", "Path to the .flow file").examples(EDGE_LIST_EXAMPLES).trackedAction(processContext, async (file) => {
+    const { listEdgesInFlow } = await import("./edge-service-e77bndbe.js");
+    const [error, result] = await catchError(listEdgesInFlow(file));
+    if (error) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Error listing edges",
+        Instructions: error.message
+      });
+      processContext.exit(1);
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "EdgeListSuccess",
+      Data: {
+        Edges: result.edges,
+        Count: result.count
+      }
+    });
+  });
+  edge.command("add").description("Add an edge between two nodes in a Flow file").argument("<file>", "Path to the .flow file").argument("<source-id>", "ID of the source node").argument("<target-id>", "ID of the target node").option("--source-port <port>", 'Source port name (defaults to "output")').option("--target-port <port>", 'Target port name (defaults to "input")').examples(EDGE_ADD_EXAMPLES).trackedAction(processContext, async (file, sourceId, targetId, options) => {
+    const { addEdgeToFlow } = await import("./edge-service-e77bndbe.js");
+    const [error, result] = await catchError(addEdgeToFlow(file, sourceId, targetId, {
+      sourcePort: options.sourcePort,
+      targetPort: options.targetPort
+    }));
+    if (error) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Error adding edge",
+        Instructions: error.message
+      });
+      processContext.exit(1);
+      return;
+    }
+    if (result.alreadyExists) {
+      const warning = `Edge already exists with id "${result.edge.id}" for (${result.edge.sourceNodeId}:${result.edge.sourcePort} -> ${result.edge.targetNodeId}:${result.edge.targetPort}). No changes written.`;
+      logger.warn(warning);
+      OutputFormatter.success({
+        Result: RESULTS.Success,
+        Code: "EdgeAlreadyExists",
+        Instructions: warning,
+        Data: {
+          Edge: result.edge
+        }
+      });
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "EdgeAddSuccess",
+      Data: {
+        Edge: result.edge
+      }
+    });
+  });
+  edge.command("delete").description(`Delete an edge from a Flow file.
+Use 'uip maestro flow edge list' to find the edge ID.`).argument("<file>", "Path to the .flow file").argument("<edge-id>", "ID of the edge to delete").examples(EDGE_DELETE_EXAMPLES).trackedAction(processContext, async (file, edgeId) => runDeleteEdge(file, edgeId, "EdgeDeleteSuccess"));
+  edge.command("remove").description(`Remove an edge from a Flow file.
+Alias for 'edge delete'. Use 'uip maestro flow edge list' to find the edge ID.`).argument("<file>", "Path to the .flow file").argument("<edge-id>", "ID of the edge to remove").examples(EDGE_REMOVE_EXAMPLES).trackedAction(processContext, async (file, edgeId) => runDeleteEdge(file, edgeId, "EdgeRemoveSuccess"));
+};
+
+// src/services/flow-eval-run-format.ts
+function formatDuration(durationMs) {
+  if (durationMs === null || durationMs === undefined) {
+    return "-";
+  }
+  return `${(durationMs / 1000).toFixed(1)}s`;
+}
+function formatEvaluatorScores(scores, evaluators) {
+  if (!scores || scores.length === 0) {
+    return "-";
+  }
+  return scores.map((score) => {
+    const evaluator = evaluators.find((item) => item.id === score.evaluatorId);
+    return `${evaluator?.name ?? score.evaluatorId}: ${score.value}`;
+  }).join(", ");
+}
+function evaluatorSnapshotName(snapshot) {
+  if (typeof snapshot === "object" && snapshot !== null && !Array.isArray(snapshot) && typeof snapshot.name === "string") {
+    return snapshot.name;
+  }
+  return;
+}
+function remoteEvaluatorName(evaluatorId, evaluatorSnapshot, evaluators) {
+  return evaluators.find((item) => item.id === evaluatorId)?.name ?? evaluatorSnapshotName(evaluatorSnapshot) ?? evaluatorId;
+}
+function remoteRunScore(run) {
+  if (run.result?.scores && run.result.scores.length > 0) {
+    const sum = run.result.scores.reduce((total, score) => total + score.value, 0);
+    return Number((sum / run.result.scores.length).toFixed(4));
+  }
+  const value = run.result?.score?.value;
+  return typeof value === "number" || typeof value === "boolean" ? value : "-";
+}
+function formatRemoteEvalRunRow(run, evaluators, verbose = false) {
+  let evaluatorScores = "-";
+  let justifications = "-";
+  if (run.evaluatorRuns && run.evaluatorRuns.length > 0) {
+    evaluatorScores = run.evaluatorRuns.map((evaluatorRun) => {
+      const name = remoteEvaluatorName(evaluatorRun.evaluatorId, evaluatorRun.evaluatorSnapshot, evaluators);
+      const score = evaluatorRun.result?.score;
+      if (score?.type === "error") {
+        return `${name}: Error`;
+      }
+      return `${name}: ${score?.value ?? "-"}`;
+    }).join(", ");
+    const justificationParts = run.evaluatorRuns.filter((evaluatorRun) => evaluatorRun.result?.score?.justification).map((evaluatorRun) => {
+      const name = remoteEvaluatorName(evaluatorRun.evaluatorId, evaluatorRun.evaluatorSnapshot, evaluators);
+      return `[${name}] ${evaluatorRun.result?.score?.justification}`;
+    });
+    if (justificationParts.length > 0) {
+      justifications = justificationParts.join(" | ");
+    }
+  } else if (run.result?.scores && run.result.scores.length > 0) {
+    evaluatorScores = formatEvaluatorScores(run.result.scores, evaluators);
+  }
+  const tokens = run.completionMetrics?.tokens;
+  const duration = run.completionMetrics?.duration;
+  const error = run.errorMessage ?? (typeof run.error === "string" ? run.error : run.error?.message) ?? "-";
+  const row = {
+    DataPoint: run.evalSnapshot?.name ?? run.id,
+    Status: run.status,
+    Score: remoteRunScore(run),
+    EvaluatorScores: evaluatorScores,
+    Tokens: typeof tokens === "number" && tokens > 0 ? tokens : "-",
+    Duration: typeof duration === "number" ? formatDuration(duration) : "-",
+    Error: error
+  };
+  if (verbose) {
+    row.Justifications = justifications;
+  }
+  return row;
+}
+function isFailedRemoteRun(run) {
+  const status = run.status.toLowerCase();
+  if (status === "failed" || status === "workloadfailed" || run.errorMessage || run.error) {
+    return true;
+  }
+  if (run.result?.score?.type === "error") {
+    return true;
+  }
+  return run.evaluatorRuns?.some((evaluatorRun) => evaluatorRun.result?.score?.type === "error" || evaluatorRun.result?.score?.value === false) ?? false;
+}
+function isTerminalRemoteStatus(status) {
+  return ["completed", "partiallycompleted", "failed"].includes(status.toLowerCase());
+}
+function formatEvalSetRunRow(run, evaluators) {
+  return {
+    EvalSetRunId: run.id,
+    Status: run.status,
+    Score: run.score ?? "-",
+    DataPoints: run.numberOfEvalsExecuted ?? "-",
+    Duration: formatDuration(run.durationMilliseconds),
+    EvaluatorScores: formatEvaluatorScores(run.evaluatorScores, evaluators),
+    CreatedAt: run.createdAt
+  };
+}
+
+// src/commands/eval-run.ts
+var FLOW_EVAL_PATH_OPTION_DESCRIPTION = "Path to a Flow project directory, or a solution directory with exactly one Flow project";
+var POLL_INTERVAL_MS = 5000;
+var POLL_TIMEOUT_MS = 600000;
+var FLOW_EVAL_RUN_START_EXAMPLES = [
+  {
+    Description: "Start a Studio Web Flow evaluation run",
+    Command: 'uip maestro flow eval run start --set "Default Evaluation Set" --path ./my-solution/Flow',
+    Output: {
+      Code: "FlowEvalRunStarted",
+      Data: {
+        EvalSetRunId: "a1b2c3d4-0000-0000-0000-000000000101",
+        EvalSetName: "Default Evaluation Set",
+        DataPoints: 3,
+        Evaluators: 2
+      }
+    }
+  }
+];
+var FLOW_EVAL_RUN_STATUS_EXAMPLES = [
+  {
+    Description: "Check the status of a Studio Web Flow evaluation run",
+    Command: 'uip maestro flow eval run status a1b2c3d4-0000-0000-0000-000000000101 --set "Default Evaluation Set" --path ./my-solution/Flow',
+    Output: {
+      Code: "FlowEvalRunStatus",
+      Data: {
+        EvalSetRunId: "a1b2c3d4-0000-0000-0000-000000000101",
+        Status: "Completed",
+        Score: 0.86,
+        Duration: "42.5s"
+      }
+    }
+  }
+];
+var FLOW_EVAL_RUN_RESULTS_EXAMPLES = [
+  {
+    Description: "Show detailed per-data-point results for a Flow run",
+    Command: 'uip maestro flow eval run results a1b2c3d4-0000-0000-0000-000000000101 --set "Default Evaluation Set" --path ./my-solution/Flow',
+    Output: {
+      Code: "FlowEvalRunResults",
+      Data: [
+        {
+          DataPoint: "simple-greeting",
+          Status: "completed",
+          EvaluatorScores: "Exact: true",
+          Duration: "1.8s",
+          Error: "-"
+        }
+      ]
+    }
+  }
+];
+var FLOW_EVAL_RUN_LIST_EXAMPLES = [
+  {
+    Description: "List Studio Web evaluation runs for a Flow eval set",
+    Command: 'uip maestro flow eval run list --set "Default Evaluation Set" --path ./my-solution/Flow',
+    Output: {
+      Code: "FlowEvalRunList",
+      Data: [
+        {
+          EvalSetRunId: "a1b2c3d4-0000-0000-0000-000000000101",
+          Status: "Completed",
+          Score: 0.86,
+          DataPoints: 3,
+          Duration: "42.5s",
+          CreatedAt: "2026-04-15T10:30:00Z"
+        }
+      ]
+    }
+  }
+];
+var FLOW_EVAL_RUN_COMPARE_EXAMPLES = [
+  {
+    Description: "Compare two Studio Web Flow evaluation runs",
+    Command: 'uip maestro flow eval run compare a1b2c3d4-0000-0000-0000-000000000101 --compare-to a1b2c3d4-0000-0000-0000-000000000102 --set "Default Evaluation Set" --path ./my-solution/Flow',
+    Output: {
+      Code: "FlowEvalRunComparison",
+      Data: {
+        RunA: {
+          Id: "a1b2c3d4-0000-0000-0000-000000000101",
+          Score: 0.86,
+          Status: "Completed"
+        },
+        RunB: {
+          Id: "a1b2c3d4-0000-0000-0000-000000000102",
+          Score: 0.8,
+          Status: "Completed"
+        },
+        ScoreDelta: 0.06
+      }
+    }
+  }
+];
+function addTargetOptions(command) {
+  return command.requiredOption("--set <name>", "Evaluation set name or ID").option("--solution-id <id>", "Solution ID from Studio Web").option("--project-id <id>", "Flow project ID from Studio Web (reads from parent .uipx or SolutionStorage.json if not provided)").option("--path <path>", FLOW_EVAL_PATH_OPTION_DESCRIPTION, ".");
+}
+function addStartOptions(command) {
+  return addTargetOptions(command).option("--entry-point <entry>", "Flow entry point path (/Main.bpmn#start) or start node ID").option("--folder-key <key>", "Orchestrator folder key. Uses the personal workspace if not provided.").option("--debug-mode <mode>", "Studio Web debug mode override", (value) => Number.parseInt(value, 10));
+}
+function outputError(message, error) {
+  OutputFormatter.error({
+    Result: RESULTS.Failure,
+    Message: message,
+    Instructions: error.message
+  });
+  processContext.exit(1);
+}
+async function resolveStudioWebConfig() {
+  const { getLoginStatusAsync } = await import("./index-1kgxzh8x.js");
+  const [loginError, login] = await catchError(getLoginStatusAsync());
+  if (loginError) {
+    throw new Error(loginError.message);
+  }
+  if (login.loginStatus !== "Logged in" || !login.baseUrl) {
+    throw new Error("Not logged in. Run 'uip login' first.");
+  }
+  if (!login.organizationId) {
+    throw new Error("Organization ID not available from login.");
+  }
+  if (!login.tenantId) {
+    throw new Error("Tenant ID not available from login.");
+  }
+  if (!login.tenantName) {
+    throw new Error("Tenant name not available from login.");
+  }
+  if (!login.accessToken) {
+    throw new Error("Access token not available from login.");
+  }
+  if (!login.organizationName) {
+    throw new Error("Organization name not available from login. Required for Studio Web evaluation.");
+  }
+  return {
+    baseUrl: login.baseUrl,
+    organizationId: login.organizationId,
+    tenantId: login.tenantId,
+    tenantName: login.tenantName,
+    authToken: login.accessToken,
+    organizationName: login.organizationName
+  };
+}
+async function pollRemoteEvalSetRun(service, config, workloadId, evalSetRunId, timeoutMs) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    const [error, run] = await catchError(service.getRemoteEvalSetRun(config, workloadId, evalSetRunId));
+    if (error) {
+      OutputFormatter.log({
+        Message: `Polling error: ${error.message}. Retrying...`
+      });
+    } else if (run) {
+      if (isTerminalRemoteStatus(run.status)) {
+        return run;
+      }
+      OutputFormatter.log({
+        Message: `Status: ${run.status}... (${Math.round((Date.now() - start) / 1000)}s)`
+      });
+    }
+    await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+  }
+  throw new Error(`Evaluation timed out after ${timeoutMs / 1000} seconds`);
+}
+async function outputCompletedRemoteRun(service, config, projectPath, startResult, timeoutSeconds) {
+  const timeoutMs = timeoutSeconds !== undefined ? timeoutSeconds * 1000 : POLL_TIMEOUT_MS;
+  const finalRun = await pollRemoteEvalSetRun(service, config, startResult.context.workloadId, startResult.evalSetRunId, timeoutMs);
+  const [evalRuns, evaluators] = await Promise.all([
+    service.getRemoteEvalRuns(config, startResult.context.workloadId, startResult.evalSetRunId),
+    service.listEvaluators(projectPath)
+  ]);
+  OutputFormatter.success({
+    Result: RESULTS.Success,
+    Code: "FlowEvalRunCompleted",
+    Data: {
+      Status: finalRun.status,
+      Score: finalRun.score ?? "-",
+      Duration: formatDuration(finalRun.durationMilliseconds),
+      EvaluatorScores: formatEvaluatorScores(finalRun.evaluatorScores, evaluators),
+      DataPoints: evalRuns.length
+    }
+  });
+  if (evalRuns.length > 0) {
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "FlowEvalRunResults",
+      Data: evalRuns.map((run) => formatRemoteEvalRunRow(run, evaluators))
+    });
+  }
+}
+async function exportRows(exportFormat, rows) {
+  const fs = getFileSystem();
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+  if (exportFormat === "json") {
+    const filePath = fs.path.resolve(`flow-eval-results-${timestamp}.json`);
+    await fs.writeFile(filePath, JSON.stringify(rows, null, 2));
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "FlowEvalRunExported",
+      Data: { Format: "json", File: filePath, Records: rows.length }
+    });
+    return;
+  }
+  if (exportFormat === "csv") {
+    const filePath = fs.path.resolve(`flow-eval-results-${timestamp}.csv`);
+    const headers = Object.keys(rows[0] ?? {});
+    const csvRows = [
+      headers.join(","),
+      ...rows.map((row) => headers.map((header) => {
+        const value = String(row[header] ?? "");
+        return value.includes(",") || value.includes('"') || value.includes(`
+`) ? `"${value.replace(/"/g, '""')}"` : value;
+      }).join(","))
+    ];
+    await fs.writeFile(filePath, csvRows.join(`
+`));
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "FlowEvalRunExported",
+      Data: { Format: "csv", File: filePath, Records: rows.length }
+    });
+    return;
+  }
+  throw new Error(`Unknown export format "${exportFormat}". Use "json" or "csv".`);
+}
+async function resolveRemoteTarget(service, options, config, requireSolutionId = false) {
+  return service.resolveRemoteEvalTarget(options.path, options.set, {
+    solutionId: options.solutionId,
+    projectId: options.projectId
+  }, requireSolutionId, config);
+}
+function registerEvalRunCommand(evalCmd) {
+  const runCmd = evalCmd.command("run").description("Run Flow evaluation sets in Studio Web");
+  addStartOptions(runCmd.command("start").description("Start a Studio Web evaluation run (Flow solution must be available in Studio Web)")).option("--wait", "Wait for the evaluation to complete and show results").option("--timeout <seconds>", "Timeout in seconds for --wait polling", (value) => Number.parseInt(value, 10)).examples(FLOW_EVAL_RUN_START_EXAMPLES).trackedAction(processContext, async (options) => {
+    const [error] = await catchError((async () => {
+      const config = await resolveStudioWebConfig();
+      const { FlowEvalRunService } = await import("./flow-eval-run-service-01kdky72.js");
+      const service = new FlowEvalRunService;
+      const result = await service.startRemoteEvalRun(options.path, options.set, config, {
+        solutionId: options.solutionId,
+        projectId: options.projectId,
+        entryPoint: options.entryPoint,
+        folderKey: options.folderKey,
+        debugMode: options.debugMode
+      });
+      OutputFormatter.success({
+        Result: RESULTS.Success,
+        Code: "FlowEvalRunStarted",
+        Data: {
+          EvalSetRunId: result.evalSetRunId,
+          EvalSetName: result.evalSetName,
+          DataPoints: result.dataPoints,
+          Evaluators: result.evaluators,
+          Status: result.status
+        },
+        Instructions: options.wait ? "Waiting for completion..." : `Monitor with: uip maestro flow eval run status ${result.evalSetRunId} --set "${options.set}" --path ${options.path}`
+      });
+      if (options.wait) {
+        await outputCompletedRemoteRun(service, config, options.path, result, options.timeout);
+      }
+    })());
+    if (error) {
+      outputError("Failed to start flow evaluation run", error);
+    }
+  });
+  addTargetOptions(runCmd.command("status").description("Check the status of a Studio Web Flow evaluation run").argument("<evalSetRunId>", "Evaluation set run ID")).examples(FLOW_EVAL_RUN_STATUS_EXAMPLES).trackedAction(processContext, async (evalSetRunId, options) => {
+    const [error] = await catchError((async () => {
+      const config = await resolveStudioWebConfig();
+      const { FlowEvalRunService } = await import("./flow-eval-run-service-01kdky72.js");
+      const service = new FlowEvalRunService;
+      const target = await resolveRemoteTarget(service, options, config);
+      const [run, evaluators] = await Promise.all([
+        service.getRemoteEvalSetRun(config, target.workloadId, evalSetRunId),
+        service.listEvaluators(target.projectPath)
+      ]);
+      OutputFormatter.success({
+        Result: RESULTS.Success,
+        Code: "FlowEvalRunStatus",
+        Data: {
+          EvalSetRunId: run.id,
+          Status: run.status,
+          Score: run.score ?? "-",
+          Duration: formatDuration(run.durationMilliseconds),
+          EvaluatorScores: formatEvaluatorScores(run.evaluatorScores, evaluators)
+        }
+      });
+    })());
+    if (error) {
+      outputError("Failed to get flow evaluation run status", error);
+    }
+  });
+  addTargetOptions(runCmd.command("results").description("Get detailed results for a Studio Web Flow evaluation run").argument("<evalSetRunId>", "Evaluation set run ID")).option("--only-failed", "Show only failed or errored data points").option("--verbose", "Include evaluator justifications in output").option("--export-format <json|csv>", "Export results to file (json or csv)").examples(FLOW_EVAL_RUN_RESULTS_EXAMPLES).trackedAction(processContext, async (evalSetRunId, options) => {
+    const [error] = await catchError((async () => {
+      const config = await resolveStudioWebConfig();
+      const { FlowEvalRunService } = await import("./flow-eval-run-service-01kdky72.js");
+      const service = new FlowEvalRunService;
+      const target = await resolveRemoteTarget(service, options, config);
+      let evalRuns = await service.getRemoteEvalRuns(config, target.workloadId, evalSetRunId);
+      if (options.onlyFailed) {
+        evalRuns = evalRuns.filter(isFailedRemoteRun);
+      }
+      if (evalRuns.length === 0) {
+        OutputFormatter.success({
+          Result: RESULTS.Success,
+          Code: "FlowEvalRunResults",
+          Data: []
+        });
+        return;
+      }
+      const evaluators = await service.listEvaluators(target.projectPath);
+      const rows = evalRuns.map((run) => formatRemoteEvalRunRow(run, evaluators, options.verbose));
+      if (options.exportFormat) {
+        await exportRows(options.exportFormat, rows);
+        return;
+      }
+      OutputFormatter.success({
+        Result: RESULTS.Success,
+        Code: "FlowEvalRunResults",
+        Data: rows
+      });
+    })());
+    if (error) {
+      outputError("Failed to get flow evaluation results", error);
+    }
+  });
+  addTargetOptions(runCmd.command("list").description("List Studio Web evaluation runs for a Flow eval set")).examples(FLOW_EVAL_RUN_LIST_EXAMPLES).trackedAction(processContext, async (options) => {
+    const [error] = await catchError((async () => {
+      const config = await resolveStudioWebConfig();
+      const { FlowEvalRunService } = await import("./flow-eval-run-service-01kdky72.js");
+      const service = new FlowEvalRunService;
+      const target = await resolveRemoteTarget(service, options, config);
+      const runs = await service.listRemoteEvalSetRuns(config, target.workloadId, target.evalSet.id);
+      if (runs.length === 0) {
+        OutputFormatter.success({
+          Result: RESULTS.Success,
+          Code: "FlowEvalRunList",
+          Data: []
+        });
+        return;
+      }
+      const evaluators = await service.listEvaluators(target.projectPath);
+      OutputFormatter.success({
+        Result: RESULTS.Success,
+        Code: "FlowEvalRunList",
+        Data: runs.map((run) => formatEvalSetRunRow(run, evaluators))
+      });
+    })());
+    if (error) {
+      outputError("Failed to list flow evaluation runs", error);
+    }
+  });
+  addTargetOptions(runCmd.command("compare").description("Compare results of two Studio Web Flow evaluation runs").argument("<evalSetRunId>", "First evaluation set run ID").requiredOption("--compare-to <id>", "Second evaluation set run ID to compare against")).examples(FLOW_EVAL_RUN_COMPARE_EXAMPLES).trackedAction(processContext, async (evalSetRunId, options) => {
+    const [error] = await catchError((async () => {
+      const config = await resolveStudioWebConfig();
+      const { FlowEvalRunService } = await import("./flow-eval-run-service-01kdky72.js");
+      const service = new FlowEvalRunService;
+      const target = await resolveRemoteTarget(service, options, config);
+      const [runsA, runsB, runMetaA, runMetaB] = await Promise.all([
+        service.getRemoteEvalRuns(config, target.workloadId, evalSetRunId),
+        service.getRemoteEvalRuns(config, target.workloadId, options.compareTo),
+        service.getRemoteEvalSetRun(config, target.workloadId, evalSetRunId),
+        service.getRemoteEvalSetRun(config, target.workloadId, options.compareTo)
+      ]);
+      OutputFormatter.success({
+        Result: RESULTS.Success,
+        Code: "FlowEvalRunComparison",
+        Data: buildComparison(evalSetRunId, options.compareTo, runMetaA, runMetaB, runsA, runsB)
+      });
+    })());
+    if (error) {
+      outputError("Failed to compare flow evaluation runs", error);
+    }
+  });
+}
+function buildComparison(evalSetRunId, compareTo, runMetaA, runMetaB, runsA, runsB) {
+  const runsBByName = new Map;
+  for (const run of runsB) {
+    runsBByName.set(run.evalSnapshot?.name ?? run.id, run);
+  }
+  const dataPoints = runsA.map((runA) => {
+    const name = runA.evalSnapshot?.name ?? runA.id;
+    const runB = runsBByName.get(name);
+    const scoreA = remoteRunScore(runA);
+    const scoreB = runB ? remoteRunScore(runB) : "-";
+    let delta = "-";
+    if (typeof scoreA === "number" && typeof scoreB === "number") {
+      delta = Number((scoreA - scoreB).toFixed(4));
+    }
+    return {
+      DataPoint: name,
+      ScoreA: scoreA,
+      ScoreB: scoreB,
+      Delta: delta,
+      StatusA: runA.status,
+      StatusB: runB?.status ?? "-"
+    };
+  });
+  return {
+    RunA: {
+      Id: evalSetRunId,
+      Score: runMetaA.score ?? "-",
+      Status: runMetaA.status
+    },
+    RunB: {
+      Id: compareTo,
+      Score: runMetaB.score ?? "-",
+      Status: runMetaB.status
+    },
+    ScoreDelta: typeof runMetaA.score === "number" && typeof runMetaB.score === "number" ? Number((runMetaA.score - runMetaB.score).toFixed(4)) : "-",
+    DataPoints: dataPoints
+  };
+}
+
+// src/commands/eval.ts
+var FLOW_EVAL_PATH_OPTION_DESCRIPTION2 = "Path to a Flow project directory, or a solution directory with exactly one Flow project";
+function parseJsonValue(raw, label) {
+  try {
+    return JSON.parse(raw);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Invalid JSON for ${label}: ${message}`);
+  }
+}
+function parseJsonObject(raw, label) {
+  const parsed = JSON.parse(raw);
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error(`${label} must be a JSON object`);
+  }
+  return parsed;
+}
+function parseCriteriaOption(raw) {
+  const parsed = parseJsonObject(raw, "--criteria");
+  const criteria = {};
+  for (const [key, value] of Object.entries(parsed)) {
+    if (value === null || value === undefined) {
+      criteria[key] = value;
+    } else if (typeof value === "object" && !Array.isArray(value)) {
+      criteria[key] = value;
+    } else {
+      throw new Error(`--criteria value for "${key}" must be a JSON object or null`);
+    }
+  }
+  return criteria;
+}
+function parseCommaSeparated(value) {
+  if (value === undefined) {
+    return;
+  }
+  return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
+function collectInputFile(value, previous) {
+  return [...previous, value];
+}
+function parseInputFiles(raw) {
+  return raw.map((entry) => {
+    const eq = entry.indexOf("=");
+    if (eq <= 0 || eq === entry.length - 1) {
+      throw new Error(`--input-file must be "<key>=<path>" (got "${entry}")`);
+    }
+    const key = entry.slice(0, eq).trim();
+    const sourcePath = entry.slice(eq + 1).trim();
+    if (!key || !sourcePath) {
+      throw new Error(`--input-file must be "<key>=<path>" (got "${entry}")`);
+    }
+    return { key, sourcePath };
+  });
+}
+function outputError2(message, error) {
+  OutputFormatter.error({
+    Result: RESULTS.Failure,
+    Message: message,
+    Instructions: error.message
+  });
+  processContext.exit(1);
+}
+function registerEvalCommand(program) {
+  const evalCmd = program.command("eval").description("Manage and run Flow evaluation sets");
+  registerEvaluatorCommands(evalCmd);
+  registerEvalSetCommands(evalCmd);
+  registerEvaluationCommands(evalCmd);
+  registerSimulationCommands(evalCmd);
+  registerEvalRunCommand(evalCmd);
+}
+function registerEvaluatorCommands(evalCmd) {
+  const evaluator = evalCmd.command("evaluator").description("Manage Flow evaluators");
+  evaluator.command("add").description("Add an evaluator to the flow project").argument("<name>", "Evaluator name").requiredOption("--type <type>", `Evaluator type: ${evaluatorTypeAliases().join(", ")}`).option("--description <text>", "Evaluator description").option("--target-key <key>", "Target output key", "*").option("--model <model>", "LLM model for LLM judge evaluators").option("--prompt <prompt>", "Custom LLM judge prompt").option("--path <path>", FLOW_EVAL_PATH_OPTION_DESCRIPTION2, ".").trackedAction(processContext, async (name, options) => {
+    const [error] = await catchError((async () => {
+      const { FlowEvalService } = await import("./flow-eval-service-ft8e16jz.js");
+      const service = new FlowEvalService;
+      const created = await service.addEvaluator(options.path, {
+        name,
+        type: options.type,
+        description: options.description,
+        targetOutputKey: options.targetKey,
+        model: options.model,
+        prompt: options.prompt
+      });
+      OutputFormatter.success({
+        Result: RESULTS.Success,
+        Code: "FlowEvalEvaluatorAdd",
+        Data: {
+          Name: created.name,
+          Id: created.id,
+          Type: created.evaluatorTypeId,
+          File: created.fileName
+        }
+      });
+    })());
+    if (error) {
+      outputError2("Failed to add evaluator", error);
+    }
+  });
+  evaluator.command("list").description("List evaluators in a flow project").option("--path <path>", FLOW_EVAL_PATH_OPTION_DESCRIPTION2, ".").trackedAction(processContext, async (options) => {
+    const [error] = await catchError((async () => {
+      const { FlowEvalService } = await import("./flow-eval-service-ft8e16jz.js");
+      const service = new FlowEvalService;
+      const evaluators = await service.listEvaluators(options.path);
+      OutputFormatter.success({
+        Result: RESULTS.Success,
+        Code: "FlowEvalEvaluatorList",
+        Data: evaluators.map((item) => ({
+          Name: item.name ?? String(item.evaluatorConfig.name ?? ""),
+          Id: item.id,
+          Type: item.evaluatorTypeId,
+          TargetKey: item.evaluatorConfig.targetOutputKey ?? "*",
+          File: item.fileName
+        }))
+      });
+    })());
+    if (error) {
+      outputError2("Failed to list evaluators", error);
+    }
+  });
+  evaluator.command("remove").description("Remove an evaluator from a flow project").argument("<id>", "Evaluator ID, name, or file base name").option("--path <path>", FLOW_EVAL_PATH_OPTION_DESCRIPTION2, ".").trackedAction(processContext, async (id, options) => {
+    const [error] = await catchError((async () => {
+      const { FlowEvalService } = await import("./flow-eval-service-ft8e16jz.js");
+      const service = new FlowEvalService;
+      const removed = await service.removeEvaluator(options.path, id);
+      if (!removed) {
+        throw new Error(`Evaluator "${id}" not found`);
+      }
+      OutputFormatter.success({
+        Result: RESULTS.Success,
+        Code: "FlowEvalEvaluatorRemove",
+        Data: { Status: "Evaluator removed", Id: id }
+      });
+    })());
+    if (error) {
+      outputError2("Failed to remove evaluator", error);
+    }
+  });
+}
+function registerEvalSetCommands(evalCmd) {
+  const set = evalCmd.command("set").description("Manage evaluation sets");
+  set.command("add").description("Create an evaluation set").argument("<name>", "Evaluation set name").option("--evaluators <refs>", "Comma-separated evaluator IDs or file base names (default: all)").option("--entry-point <id>", "Entry point node id stored as the eval set's selectedEntrypoint. An agent node id creates a node-scoped eval set (evaluates that node in isolation)").option("--path <path>", FLOW_EVAL_PATH_OPTION_DESCRIPTION2, ".").trackedAction(processContext, async (name, options) => {
+    const [error] = await catchError((async () => {
+      const { FlowEvalService } = await import("./flow-eval-service-ft8e16jz.js");
+      const { readEvalSetScope, readNodeTargetId } = await import("./flow-eval-node-target-c6wea7rz.js");
+      const service = new FlowEvalService;
+      const created = await service.addEvalSet(options.path, {
+        name,
+        evaluatorRefs: parseCommaSeparated(options.evaluators),
+        entryPoint: options.entryPoint
+      });
+      const targetNode = readNodeTargetId(created);
+      OutputFormatter.success({
+        Result: RESULTS.Success,
+        Code: "FlowEvalSetAdd",
+        Data: {
+          Name: created.name,
+          Id: created.id,
+          Evaluators: created.evaluatorRefs.length,
+          File: created.fileName,
+          Scope: readEvalSetScope(created),
+          ...targetNode !== undefined ? { TargetNode: targetNode } : {}
+        }
+      });
+    })());
+    if (error) {
+      outputError2("Failed to create evaluation set", error);
+    }
+  });
+  set.command("list").description("List evaluation sets").option("--path <path>", FLOW_EVAL_PATH_OPTION_DESCRIPTION2, ".").trackedAction(processContext, async (options) => {
+    const [error] = await catchError((async () => {
+      const { FlowEvalService } = await import("./flow-eval-service-ft8e16jz.js");
+      const { readEvalSetScope, readNodeTargetId } = await import("./flow-eval-node-target-c6wea7rz.js");
+      const service = new FlowEvalService;
+      const sets = await service.listEvalSets(options.path);
+      OutputFormatter.success({
+        Result: RESULTS.Success,
+        Code: "FlowEvalSetList",
+        Data: sets.map((item) => {
+          const targetNode = readNodeTargetId(item);
+          return {
+            Name: item.name,
+            Id: item.id,
+            DataPoints: item.evaluations.length,
+            Evaluators: item.evaluatorRefs.length,
+            File: item.fileName,
+            Scope: readEvalSetScope(item),
+            ...targetNode !== undefined ? { TargetNode: targetNode } : {}
+          };
+        })
+      });
+    })());
+    if (error) {
+      outputError2("Failed to list evaluation sets", error);
+    }
+  });
+  set.command("remove").description("Remove an evaluation set").argument("<id>", "Evaluation set ID, name, or file base name").option("--path <path>", FLOW_EVAL_PATH_OPTION_DESCRIPTION2, ".").trackedAction(processContext, async (id, options) => {
+    const [error] = await catchError((async () => {
+      const { FlowEvalService } = await import("./flow-eval-service-ft8e16jz.js");
+      const service = new FlowEvalService;
+      const removed = await service.removeEvalSet(options.path, id);
+      if (!removed) {
+        throw new Error(`Evaluation set "${id}" not found`);
+      }
+      OutputFormatter.success({
+        Result: RESULTS.Success,
+        Code: "FlowEvalSetRemove",
+        Data: { Status: "Evaluation set removed", Id: id }
+      });
+    })());
+    if (error) {
+      outputError2("Failed to remove evaluation set", error);
+    }
+  });
+}
+function registerEvaluationCommands(evalCmd) {
+  evalCmd.command("add").description("Add a data point to an evaluation set").argument("<name>", "Data point name").requiredOption("--set <name>", "Evaluation set name or ID").option("--inputs <json>", "Input values as a JSON object").option("--input-file <key=path>", "Attach a file as input <key>; repeatable", collectInputFile, []).option("--expected <json>", "Expected output as a JSON object").option("--criteria <json>", "Per-evaluator criteria JSON object keyed by evaluator id").option("--search-text <text>", "Search text for contains evaluators").option("--path <path>", FLOW_EVAL_PATH_OPTION_DESCRIPTION2, ".").trackedAction(processContext, async (name, options) => {
+    const [error] = await catchError((async () => {
+      if (options.inputs === undefined && options.inputFile.length === 0) {
+        throw new Error("Provide --inputs and/or --input-file");
+      }
+      const inputs = options.inputs === undefined ? {} : parseJsonObject(options.inputs, "--inputs");
+      const inputFiles = parseInputFiles(options.inputFile);
+      const expectedOutput = options.expected ? parseJsonObject(options.expected, "--expected") : undefined;
+      const criteria = options.criteria ? parseCriteriaOption(options.criteria) : undefined;
+      const { FlowEvalService } = await import("./flow-eval-service-ft8e16jz.js");
+      const service = new FlowEvalService;
+      const evaluation = await service.addEvaluation(options.path, options.set, {
+        name,
+        inputs,
+        inputFiles,
+        expectedOutput,
+        criteria,
+        searchText: options.searchText
+      });
+      OutputFormatter.success({
+        Result: RESULTS.Success,
+        Code: "FlowEvalAdd",
+        Data: {
+          Status: "Data point added",
+          Name: evaluation.name,
+          Id: evaluation.id,
+          Set: options.set
+        }
+      });
+    })());
+    if (error) {
+      outputError2("Failed to add evaluation data point", error);
+    }
+  });
+  evalCmd.command("list").description("List data points in an evaluation set").requiredOption("--set <name>", "Evaluation set name or ID").option("--path <path>", FLOW_EVAL_PATH_OPTION_DESCRIPTION2, ".").trackedAction(processContext, async (options) => {
+    const [error] = await catchError((async () => {
+      const { FlowEvalService } = await import("./flow-eval-service-ft8e16jz.js");
+      const service = new FlowEvalService;
+      const evaluations = await service.listEvaluations(options.path, options.set);
+      OutputFormatter.success({
+        Result: RESULTS.Success,
+        Code: "FlowEvalList",
+        Data: evaluations.map((item) => ({
+          Name: item.name,
+          Id: item.id,
+          Inputs: JSON.stringify(item.inputs),
+          Expected: item.expectedOutput ? JSON.stringify(item.expectedOutput) : "-",
+          Evaluators: Object.keys(item.evaluationCriterias ?? {}).length
+        }))
+      });
+    })());
+    if (error) {
+      outputError2("Failed to list evaluation data points", error);
+    }
+  });
+  evalCmd.command("remove").description("Remove a data point from an evaluation set").argument("<id>", "Data point ID or name").requiredOption("--set <name>", "Evaluation set name or ID").option("--path <path>", FLOW_EVAL_PATH_OPTION_DESCRIPTION2, ".").trackedAction(processContext, async (id, options) => {
+    const [error] = await catchError((async () => {
+      const { FlowEvalService } = await import("./flow-eval-service-ft8e16jz.js");
+      const service = new FlowEvalService;
+      const removed = await service.removeEvaluation(options.path, options.set, id);
+      if (!removed) {
+        throw new Error(`Data point "${id}" not found`);
+      }
+      OutputFormatter.success({
+        Result: RESULTS.Success,
+        Code: "FlowEvalRemove",
+        Data: { Status: "Data point removed", Id: id }
+      });
+    })());
+    if (error) {
+      outputError2("Failed to remove evaluation data point", error);
+    }
+  });
+}
+function registerSimulationCommands(evalCmd) {
+  const simulation = evalCmd.command("simulation").description("Manage simulations on eval data points");
+  simulation.command("add").description("Add or update a simulation on a data point").argument("<component-id>", "Component ID to simulate").requiredOption("--set <name>", "Evaluation set name or ID").requiredOption("--data-point <id>", "Data point name or ID").requiredOption("--strategy <strategy>", "Simulation strategy: Static or Llm").option("--component-type <type>", "Component type (defaults to Node when --parent is used)").option("--component-description <text>", "Component description").option("--simulation-instructions <text>", "Simulation instructions (for Llm strategy)").option("--mock-value <json>", "Mock output value as JSON (for Static strategy)").option("--parent <component-id>", "Parent agent component ID. When set, the simulation is added as a child tool simulation on the parent agent node.").option("--path <path>", FLOW_EVAL_PATH_OPTION_DESCRIPTION2, ".").trackedAction(processContext, async (componentId, options) => {
+    const [error] = await catchError((async () => {
+      const strategy = options.strategy;
+      if (strategy !== "Static" && strategy !== "Llm") {
+        throw new Error(`--strategy must be Static or Llm (got "${strategy}")`);
+      }
+      const componentType = options.componentType ?? (options.parent !== undefined ? "Node" : undefined);
+      if (componentType === undefined) {
+        throw new Error("--component-type is required (or use --parent to default to Node)");
+      }
+      if (strategy === "Static" && options.mockValue === undefined) {
+        throw new Error("--mock-value is required for the Static strategy");
+      }
+      if (strategy === "Llm" && options.simulationInstructions === undefined) {
+        throw new Error("--simulation-instructions is required for the Llm strategy");
+      }
+      const mockValue = options.mockValue !== undefined ? parseJsonValue(options.mockValue, "--mock-value") : undefined;
+      const simulation2 = {
+        componentId,
+        componentType,
+        componentDescription: options.componentDescription,
+        simulationStrategy: strategy,
+        simulationInstruction: options.simulationInstructions,
+        mockValue
+      };
+      const { FlowEvalService } = await import("./flow-eval-service-ft8e16jz.js");
+      const service = new FlowEvalService;
+      if (options.parent !== undefined) {
+        const created = await service.addChildSimulation(options.path, options.set, options.dataPoint, options.parent, simulation2);
+        OutputFormatter.success({
+          Result: RESULTS.Success,
+          Code: "FlowEvalChildSimulationAdd",
+          Data: {
+            ComponentId: created.componentId,
+            ComponentType: created.componentType,
+            Strategy: created.simulationStrategy,
+            Parent: options.parent,
+            DataPoint: options.dataPoint,
+            Set: options.set
+          }
+        });
+      } else {
+        const created = await service.addSimulation(options.path, options.set, options.dataPoint, simulation2);
+        OutputFormatter.success({
+          Result: RESULTS.Success,
+          Code: "FlowEvalSimulationAdd",
+          Data: {
+            ComponentId: created.componentId,
+            ComponentType: created.componentType,
+            Strategy: created.simulationStrategy,
+            DataPoint: options.dataPoint,
+            Set: options.set
+          }
+        });
+      }
+    })());
+    if (error) {
+      outputError2("Failed to add simulation", error);
+    }
+  });
+  simulation.command("list").description("List simulations on a data point").requiredOption("--set <name>", "Evaluation set name or ID").requiredOption("--data-point <id>", "Data point name or ID").option("--parent <component-id>", "Parent agent component ID. When set, lists child tool simulations on the parent agent node.").option("--path <path>", FLOW_EVAL_PATH_OPTION_DESCRIPTION2, ".").trackedAction(processContext, async (options) => {
+    const [error] = await catchError((async () => {
+      const { FlowEvalService } = await import("./flow-eval-service-ft8e16jz.js");
+      const service = new FlowEvalService;
+      const simulations = options.parent !== undefined ? await service.listChildSimulations(options.path, options.set, options.dataPoint, options.parent) : await service.listSimulations(options.path, options.set, options.dataPoint);
+      OutputFormatter.success({
+        Result: RESULTS.Success,
+        Code: options.parent !== undefined ? "FlowEvalChildSimulationList" : "FlowEvalSimulationList",
+        Data: simulations.map((s) => ({
+          ComponentId: s.componentId,
+          ComponentType: s.componentType,
+          ComponentDescription: s.componentDescription ?? "-",
+          Strategy: s.simulationStrategy,
+          Instruction: s.simulationInstruction ?? "-",
+          ...options.parent !== undefined ? { Parent: options.parent } : {}
+        }))
+      });
+    })());
+    if (error) {
+      outputError2("Failed to list simulations", error);
+    }
+  });
+  simulation.command("remove").description("Remove a simulation from a data point").argument("<component-id>", "Component ID to remove").requiredOption("--set <name>", "Evaluation set name or ID").requiredOption("--data-point <id>", "Data point name or ID").option("--parent <component-id>", "Parent agent component ID. When set, removes a child tool simulation from the parent agent node.").option("--path <path>", FLOW_EVAL_PATH_OPTION_DESCRIPTION2, ".").trackedAction(processContext, async (componentId, options) => {
+    const [error] = await catchError((async () => {
+      const { FlowEvalService } = await import("./flow-eval-service-ft8e16jz.js");
+      const service = new FlowEvalService;
+      const removed = options.parent !== undefined ? await service.removeChildSimulation(options.path, options.set, options.dataPoint, options.parent, componentId) : await service.removeSimulation(options.path, options.set, options.dataPoint, componentId);
+      if (!removed) {
+        throw new Error(options.parent !== undefined ? `Child simulation for component "${componentId}" not found on parent "${options.parent}"` : `Simulation for component "${componentId}" not found`);
+      }
+      OutputFormatter.success({
+        Result: RESULTS.Success,
+        Code: options.parent !== undefined ? "FlowEvalChildSimulationRemove" : "FlowEvalSimulationRemove",
+        Data: {
+          Status: options.parent !== undefined ? "Child simulation removed" : "Simulation removed",
+          ComponentId: componentId,
+          ...options.parent !== undefined ? { Parent: options.parent } : {}
+        }
+      });
+    })());
+    if (error) {
+      outputError2("Failed to remove simulation", error);
+    }
+  });
+}
+
+// src/commands/hitl.ts
+var VALID_PRIORITIES = ["Low", "Medium", "High"];
+function parsePosition(value) {
+  const parts = value.split(",");
+  if (parts.length !== 2) {
+    throw new Error(`Invalid position format: "${value}". Expected "x,y" (e.g. 250,150)`);
+  }
+  const x = Number(parts[0]);
+  const y = Number(parts[1]);
+  if (Number.isNaN(x) || Number.isNaN(y)) {
+    throw new Error(`Invalid position values: "${value}". x and y must be numbers`);
+  }
+  return { x, y };
+}
+function parsePositionOption(raw) {
+  return catchError(() => parsePosition(raw));
+}
+function parseSchemaOption(raw) {
+  const [parseErr, parsed] = catchError(() => JSON.parse(raw));
+  if (parseErr)
+    return [parseErr, undefined];
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return [new Error("--schema must be a JSON object"), undefined];
+  }
+  const obj = parsed;
+  for (const key of ["inputs", "outputs", "inOuts", "outcomes"]) {
+    const val = obj[key];
+    if (val === undefined)
+      continue;
+    if (!Array.isArray(val)) {
+      return [new Error(`--schema "${key}" must be an array`), undefined];
+    }
+    const missing = val.findIndex((item) => item === null || typeof item !== "object" || typeof item.name !== "string");
+    if (missing !== -1) {
+      return [
+        new Error(`--schema "${key}[${missing}]" must have a "name" string field`),
+        undefined
+      ];
+    }
+  }
+  return [undefined, parsed];
+}
+var FLOW_HITL_ADD_EXAMPLES = [
+  {
+    Description: "Add a bare HITL node with no schema fields",
+    Command: "uip maestro flow hitl add workflow.flow",
+    Output: {
+      Code: "HitlNodeAdded",
+      Data: {
+        NodeId: "humanInTheLoop1",
+        NodeType: "uipath.human-in-the-loop",
+        Label: "Human in the Loop",
+        DefinitionAdded: true
+      }
+    }
+  },
+  {
+    Description: "Add a HITL node with label, priority, and group assignee",
+    Command: 'uip maestro flow hitl add workflow.flow --label "Invoice Review" --priority High --assignee finance-approvers',
+    Output: {
+      Code: "HitlNodeAdded",
+      Data: {
+        NodeId: "invoiceReview1",
+        NodeType: "uipath.human-in-the-loop",
+        Label: "Invoice Review",
+        DefinitionAdded: true
+      }
+    }
+  },
+  {
+    Description: "Add a HITL node with full schema (inputs, outputs, and outcomes)",
+    Command: `uip maestro flow hitl add workflow.flow --label "Approval" --schema '{"inputs":[{"name":"invoiceId","binding":"fetchInvoice1.result.invoiceId"}],"outputs":[{"name":"decision","required":true}],"outcomes":[{"name":"Approve"},{"name":"Reject"}]}'`,
+    Output: {
+      Code: "HitlNodeAdded",
+      Data: {
+        NodeId: "approval1",
+        NodeType: "uipath.human-in-the-loop",
+        Label: "Approval",
+        DefinitionAdded: true
+      }
+    }
+  }
+];
+var registerHitlCommand = (program) => {
+  const hitl = program.command("hitl").description("Add HITL (Human-in-the-Loop) nodes to a Flow file");
+  hitl.command("add").description("Add a Human-in-the-Loop node to a .flow file. Pauses flow execution and waits for a human to complete a task in Action Center.").argument("<file>", "Path to the .flow file").option("--schema <json>", 'Task schema. inputs pre-fill from flow variables (add "binding":"varName"), outputs write back (add "variable":"varName"). ' + `e.g. '{"title":"Invoice Approval","inputs":[{"name":"invoiceId"}],"outputs":[{"name":"decision","variable":"approvalDecision","required":true}],"outcomes":[{"name":"Approve"},{"name":"Reject"}]}'`).option("--priority <level>", "Task priority: Low, Medium, High (default: Low)").option("--position <x,y>", "Canvas position for the node (e.g. 250,300)").option("--label <label>", "Display label for the node").option("--assignee <email-or-group>", "Assignment criteria: user email (e.g. reviewer@company.com) or group name (e.g. finance-approvers)").examples(FLOW_HITL_ADD_EXAMPLES).trackedAction(processContext, async (file, options) => {
+    if (options.priority !== undefined && !VALID_PRIORITIES.includes(options.priority)) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Invalid priority",
+        Instructions: `Priority must be one of: ${VALID_PRIORITIES.join(", ")}`
+      });
+      processContext.exit(1);
+      return;
+    }
+    let position;
+    if (options.position !== undefined) {
+      const [posError, parsed] = parsePositionOption(options.position);
+      if (posError) {
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          Message: "Invalid --position value",
+          Instructions: extractErrorMessageSync(posError)
+        });
+        processContext.exit(1);
+        return;
+      }
+      position = parsed;
+    }
+    let schema;
+    if (options.schema !== undefined) {
+      const [schemaError, parsed] = parseSchemaOption(options.schema);
+      if (schemaError) {
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          Message: "Invalid --schema JSON",
+          Instructions: extractErrorMessageSync(schemaError)
+        });
+        processContext.exit(1);
+        return;
+      }
+      schema = parsed;
+    }
+    const { addHitlNode } = await import("./hitl-service-kvt5wms4.js");
+    const [error, result] = await catchError(addHitlNode(file, {
+      schema,
+      priority: options.priority,
+      position,
+      label: options.label,
+      assignee: options.assignee
+    }));
+    if (error) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Failed to add HITL node",
+        Instructions: extractErrorMessageSync(error)
+      });
+      processContext.exit(1);
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "HitlNodeAdded",
+      Data: {
+        NodeId: result.nodeId,
+        NodeType: result.nodeType,
+        Label: result.label,
+        DefinitionAdded: result.definitionAdded
+      }
+    });
+  });
+};
+
+// src/commands/incidents.ts
+var registerIncidentsCommand = (program) => {
+  registerSharedIncidentCommands(program, {
+    toolLabel: "Flow"
+  });
+};
+
+// src/commands/init.ts
+var FLOW_INIT_EXAMPLES = [
+  {
+    Description: "Create a new flow project. If the current directory is not already inside a solution, a parent solution named '<project>Solution' is created automatically and the flow project is nested inside it.",
+    Command: "uip maestro flow init my-flow-project",
+    Output: {
+      Code: "FlowInit",
+      Data: {
+        Status: "Created successfully",
+        Path: "/workspace/my-flow-projectSolution/my-flow-project",
+        SolutionRegistration: {
+          Status: "Registered",
+          Message: "Project registered in parent solution.",
+          Solution: "/workspace/my-flow-projectSolution/my-flow-projectSolution.uipx",
+          Project: "my-flow-project/project.uiproj",
+          ProjectId: "00000000-0000-0000-0000-000000000000",
+          Instructions: `The project is listed in the parent solution manifest.
+Packing or uploading the solution will sync solution resources automatically.`
+        },
+        AutoCreatedSolution: {
+          Name: "my-flow-projectSolution",
+          Path: "/workspace/my-flow-projectSolution",
+          SolutionFile: "/workspace/my-flow-projectSolution/my-flow-projectSolution.uipx"
+        },
+        ProjectArtifacts: { Created: true },
+        NextSteps: `The project is listed in the parent solution manifest.
+Packing or uploading the solution will sync solution resources automatically.`
+      }
+    }
+  }
+];
+var registerInitCommand = (program) => {
+  program.command("init").description("Create a new Flow project with boilerplate files. If run outside an existing solution, a parent '<name>Solution' is scaffolded automatically and the flow project is created inside it. If run inside an existing solution, the project is added to that solution.").argument("<name>", "Flow project name").option("--force", "Force initialization even if target directory exists and is not empty").option("--skip-solution-registration", "Do not auto-register this project in the surrounding solution").examples(FLOW_INIT_EXAMPLES).trackedAction(processContext, async (name, options) => {
+    const { flowInitAsync } = await import("./flow-init-service-mva4crty.js");
+    const [error, result] = await catchError(flowInitAsync(name, {
+      force: options.force,
+      skipRegistration: options.skipSolutionRegistration === true
+    }));
+    if (error) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Failed to create flow project",
+        Instructions: error.message
+      });
+      processContext.exit(1);
+      return;
+    }
+    const data = {
+      Status: "Created successfully",
+      Path: result.projectDir,
+      SolutionRegistration: result.registration
+    };
+    if (result.autoCreatedSolution) {
+      data.AutoCreatedSolution = result.autoCreatedSolution;
+    }
+    if (result.projectArtifacts) {
+      data.ProjectArtifacts = result.projectArtifacts;
+    }
+    if (result.registration.Instructions) {
+      data.NextSteps = result.registration.Instructions;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "FlowInit",
+      Data: data
+    });
+  });
+};
+
+// src/commands/instances.ts
+var registerInstancesCommand = (program) => {
+  registerSharedInstanceCommands(program, {
+    toolLabel: "Flow",
+    assetType: "flow",
+    processType: "Flow"
+  });
+};
+
+// src/commands/job.ts
+var VALID_JOB_STATES = [
+  "Pending",
+  "Running",
+  "Successful",
+  "Faulted",
+  "Stopped",
+  "Stopping",
+  "Suspended",
+  "Resumed",
+  "Terminating"
+];
+var DEFAULT_JOB_LIST_LIMIT = "50";
+var DEFAULT_JOB_LIST_OFFSET = "0";
+var DEFAULT_JOB_LIST_ORDER_BY = "Id desc";
+var FLOW_JOB_LIST_EXAMPLES = [
+  {
+    Description: "List recent Flow jobs in a folder",
+    Command: "uip maestro flow job list --folder-key c3d4e5f6-0000-0000-0000-000000000001 --limit 2",
+    Output: {
+      Code: "FlowJobList",
+      Data: [
+        {
+          key: "b2c3d4e5-0000-0000-0000-000000000001",
+          state: "Successful",
+          processName: "InvoiceFlow",
+          source: "Manual",
+          startTime: "2025-04-15T10:30:00Z",
+          endTime: "2025-04-15T10:32:11Z"
+        }
+      ]
+    }
+  }
+];
+var FLOW_JOB_STATUS_EXAMPLES = [
+  {
+    Description: "Get detailed status of a flow job",
+    Command: "uip maestro flow job status b2c3d4e5-0000-0000-0000-000000000001",
+    Output: {
+      Code: "FlowJobStatus",
+      Data: {
+        key: "b2c3d4e5-0000-0000-0000-000000000001",
+        state: "Successful",
+        startTime: "2025-04-15T10:30:00Z",
+        endTime: "2025-04-15T10:32:11Z",
+        releaseName: "InvoiceFlow",
+        processKey: "a1b2c3d4-0000-0000-0000-000000000001"
+      }
+    }
+  }
+];
+var FLOW_JOB_TRACES_ERROR_INSTRUCTIONS = "Check that the job started successfully and that traces are available before calling this command.";
+function parsePositiveInteger(value, flag) {
+  const candidate = value ?? "";
+  if (!/^\d+$/.test(candidate)) {
+    throw new Error(`Invalid ${flag} value`);
+  }
+  const parsed = Number.parseInt(candidate, 10);
+  if (parsed <= 0) {
+    throw new Error(`Invalid ${flag} value`);
+  }
+  return parsed;
+}
+function parseNonNegativeInteger(value, flag) {
+  const candidate = value ?? "";
+  if (!/^\d+$/.test(candidate)) {
+    throw new Error(`Invalid ${flag} value`);
+  }
+  return Number.parseInt(candidate, 10);
+}
+function normalizeOptionalOption(value) {
+  return value === undefined ? undefined : value.trim();
+}
+function formatDate(value) {
+  if (!value) {
+    return "";
+  }
+  const date = value instanceof Date ? value : new Date(value);
+  return Number.isNaN(date.getTime()) ? String(value) : date.toISOString();
+}
+function formatFlowJob(job) {
+  return {
+    key: job.key ?? "",
+    state: job.state ?? "",
+    processName: job.releaseName ?? "",
+    releaseKey: job.release?.key ?? "",
+    processKey: job.release?.processKey ?? "",
+    source: job.sourceType ?? "",
+    type: job.type ?? "",
+    priority: job.jobPriority ?? "",
+    machine: job.hostMachineName ?? "",
+    machineKey: job.machine?.key ?? "",
+    folderKey: job.folderKey ?? "",
+    startTime: formatDate(job.startTime),
+    endTime: formatDate(job.endTime),
+    creationTime: formatDate(job.creationTime)
+  };
+}
+function registerJobCommand(program) {
+  const jobCmd = program.command("job").description("Manage Flow jobs");
+  jobCmd.command("list").description("List Flow jobs in a folder").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("--folder-key <key>", "Folder key (GUID, defaults to authenticated folder)").option("--state <state>", `Filter by job state (${VALID_JOB_STATES.join(", ")})`).option("--process-name <name>", "Filter by Flow process name (contains match)").option("-l, --limit <number>", "Number of items to return", DEFAULT_JOB_LIST_LIMIT).option("--offset <number>", "Number of items to skip", DEFAULT_JOB_LIST_OFFSET).option("--sort-by <field>", "Sort results by field (e.g., 'Id desc')", DEFAULT_JOB_LIST_ORDER_BY).option("--all-fields", "Return all fields from the API response instead of a curated summary").option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", (value) => Number.parseInt(value, 10), 10).examples(FLOW_JOB_LIST_EXAMPLES).trackedAction(processContext, async (options) => {
+    const { getLoginStatusAsync } = await import("./index-1kgxzh8x.js");
+    const [loginError, loginStatus] = await catchError(getLoginStatusAsync({
+      ensureTokenValidityMinutes: options.loginValidity
+    }));
+    if (loginError) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: loginError.message,
+        Instructions: instructionsFor("auth", loginError)
+      });
+      processContext.exit(1);
+      return;
+    }
+    if (loginStatus.loginStatus !== "Logged in" || !loginStatus.baseUrl) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Not logged in. Run 'uip login' first.",
+        Instructions: instructionsFor("auth")
+      });
+      processContext.exit(1);
+      return;
+    }
+    const normalizedOptions = {
+      tenant: normalizeOptionalOption(options.tenant),
+      folderKey: normalizeOptionalOption(options.folderKey),
+      state: normalizeOptionalOption(options.state),
+      processName: normalizeOptionalOption(options.processName),
+      orderBy: normalizeOptionalOption(options.sortBy)
+    };
+    const tenantName = normalizedOptions.tenant || loginStatus.tenantName;
+    if (!tenantName || !loginStatus.organizationId) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Missing tenant or organization info.",
+        Instructions: instructionsFor("identity")
+      });
+      processContext.exit(1);
+      return;
+    }
+    const state = normalizedOptions.state;
+    if (state && !VALID_JOB_STATES.includes(state)) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Invalid --state value.",
+        Instructions: `Use one of: ${VALID_JOB_STATES.join(", ")}.`
+      });
+      processContext.exit(1);
+      return;
+    }
+    let limit;
+    let offset;
+    try {
+      limit = parsePositiveInteger(options.limit ?? DEFAULT_JOB_LIST_LIMIT, "--limit");
+      offset = parseNonNegativeInteger(options.offset ?? DEFAULT_JOB_LIST_OFFSET, "--offset");
+    } catch (error) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: error instanceof Error ? error.message : "Invalid pagination value.",
+        Instructions: "Use a positive integer for --limit and a non-negative integer for --offset."
+      });
+      processContext.exit(1);
+      return;
+    }
+    const config = {
+      processKey: "",
+      folderKey: normalizedOptions.folderKey ?? "",
+      inputs: {},
+      authToken: loginStatus.accessToken ?? "",
+      organizationId: loginStatus.organizationId,
+      tenantName,
+      tenantId: loginStatus.tenantId,
+      baseUrl: loginStatus.baseUrl
+    };
+    const { listFlowJobs } = await import("./flow-api-wv8p8xbd.js");
+    const [listError, jobs] = await catchError(listFlowJobs(config, {
+      state,
+      processName: normalizedOptions.processName,
+      limit,
+      offset,
+      orderBy: normalizedOptions.orderBy || DEFAULT_JOB_LIST_ORDER_BY
+    }));
+    if (listError) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: listError.message,
+        Instructions: instructionsFor("backend", listError)
+      });
+      processContext.exit(1);
+      return;
+    }
+    const items = jobs ?? [];
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "FlowJobList",
+      Data: options.allFields ? items : items.map(formatFlowJob),
+      Pagination: {
+        Returned: items.length,
+        Limit: limit,
+        Offset: offset,
+        HasMore: items.length >= limit
+      }
+    });
+  });
+  jobCmd.command("traces").description("Stream traces for a running job").argument("<job-key>", "Job key (GUID from run command)").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("--poll-interval <ms>", "Polling interval in milliseconds", "2000").option("--traces-service <name>", "Traces service name (default: llmopstenant_)", "llmopstenant_").option("--pretty", "Show traces in human-readable format instead of raw JSON").option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).trackedAction(processContext, async (jobKey, options) => {
+    const { getLoginStatusAsync } = await import("./index-1kgxzh8x.js");
+    const [loginError, loginStatus] = await catchError(getLoginStatusAsync({
+      ensureTokenValidityMinutes: options.loginValidity
+    }));
+    if (loginError) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: loginError.message,
+        Instructions: instructionsFor("auth", loginError)
+      });
+      processContext.exit(1);
+      return;
+    }
+    if (loginStatus.loginStatus !== "Logged in" || !loginStatus.baseUrl) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Not logged in. Run 'uip login' first.",
+        Instructions: instructionsFor("auth")
+      });
+      processContext.exit(1);
+      return;
+    }
+    const tenantName = options.tenant || loginStatus.tenantName;
+    if (!tenantName || !loginStatus.organizationId) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Missing tenant or organization info.",
+        Instructions: instructionsFor("identity")
+      });
+      processContext.exit(1);
+      return;
+    }
+    const config = {
+      processKey: "",
+      folderKey: "",
+      inputs: {},
+      authToken: loginStatus.accessToken ?? "",
+      organizationId: loginStatus.organizationId,
+      tenantName,
+      tenantId: loginStatus.tenantId,
+      baseUrl: loginStatus.baseUrl,
+      tracesServiceName: options.tracesService
+    };
+    const pollIntervalMs = parseInt(options.pollInterval || "2000", 10);
+    if (!Number.isFinite(pollIntervalMs) || pollIntervalMs <= 0) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: `Invalid poll-interval: ${options.pollInterval}. Must be a positive number.`,
+        Instructions: "Provide a positive number in milliseconds."
+      });
+      processContext.exit(1);
+      return;
+    }
+    const pollSeconds = pollIntervalMs / 1000;
+    logger.info(`Streaming traces for job: ${jobKey}
+   Polling every ${pollSeconds}s...`);
+    const { formatTraceLine } = await import("./shared-utils-8xdq6f04.js");
+    const { streamJobTraces } = await import("./flow-api-wv8p8xbd.js");
+    const [tracesError, result] = await catchError(streamJobTraces(config, jobKey, {
+      onTrace: (trace) => {
+        if (options.pretty) {
+          ScreenLogger.progress(formatTraceLine(trace));
+        } else {
+          ScreenLogger.progress(JSON.stringify(trace));
+        }
+      },
+      onComplete: (result2) => {
+        ScreenLogger.progress(`Job ${jobKey}: ${result2.finalState} (${result2.duration}ms)`);
+      },
+      onError: (error) => {
+        ScreenLogger.progress(`Error: ${error.message}`);
+      },
+      pollInterval: pollIntervalMs
+    }));
+    if (tracesError) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: tracesError.message,
+        Instructions: FLOW_JOB_TRACES_ERROR_INSTRUCTIONS
+      });
+      processContext.exit(1);
+      return;
+    }
+    if (!result.success && result.error) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: result.error,
+        Instructions: FLOW_JOB_TRACES_ERROR_INSTRUCTIONS
+      });
+      processContext.exit(1);
+      return;
+    }
+    processContext.exit(result.success ? 0 : 1);
+  });
+  jobCmd.command("status").description("Get detailed status of a Flow job").argument("<job-key>", "Job key (GUID from run command)").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("--folder-key <key>", "Folder key (GUID from list command, defaults to authenticated folder)").option("--detailed", "Show full response with all fields").option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).examples(FLOW_JOB_STATUS_EXAMPLES).trackedAction(processContext, async (jobKey, options) => {
+    const { getLoginStatusAsync } = await import("./index-1kgxzh8x.js");
+    const [loginError, loginStatus] = await catchError(getLoginStatusAsync({
+      ensureTokenValidityMinutes: options.loginValidity
+    }));
+    if (loginError) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: loginError.message,
+        Instructions: instructionsFor("auth", loginError)
+      });
+      processContext.exit(1);
+      return;
+    }
+    if (loginStatus.loginStatus !== "Logged in" || !loginStatus.baseUrl) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Not logged in. Run 'uip login' first.",
+        Instructions: instructionsFor("auth")
+      });
+      processContext.exit(1);
+      return;
+    }
+    const tenantName = options.tenant || loginStatus.tenantName;
+    if (!tenantName || !loginStatus.organizationId) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Missing tenant or organization info.",
+        Instructions: instructionsFor("identity")
+      });
+      processContext.exit(1);
+      return;
+    }
+    const config = {
+      processKey: "",
+      folderKey: options.folderKey ?? "",
+      inputs: {},
+      authToken: loginStatus.accessToken ?? "",
+      organizationId: loginStatus.organizationId,
+      tenantName,
+      tenantId: loginStatus.tenantId,
+      baseUrl: loginStatus.baseUrl
+    };
+    const { getJobStatusDetailed } = await import("./flow-api-wv8p8xbd.js");
+    const [statusError, status] = await catchError(getJobStatusDetailed(config, jobKey));
+    if (statusError) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: statusError.message,
+        Instructions: instructionsFor("backend", statusError)
+      });
+      processContext.exit(1);
+      return;
+    }
+    const outputData = options.detailed ? status : {
+      key: status.key,
+      state: status.state,
+      runtimeType: status.runtimeType,
+      processType: status.processType,
+      startTime: status.startTime,
+      endTime: status.endTime,
+      creationTime: status.creationTime,
+      inputArguments: status.inputArguments,
+      outputArguments: status.outputArguments,
+      info: status.info,
+      releaseName: status.release?.name,
+      processKey: status.release?.processKey,
+      robotName: status.robot?.name,
+      hostMachineName: status.hostMachineName
+    };
+    const pendingSeconds = pendingSecondsFor(status.state, status.creationTime);
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "FlowJobStatus",
+      Data: pendingSeconds === undefined ? outputData : { ...outputData, pendingSeconds },
+      ...pendingSeconds === undefined ? {} : {
+        Instructions: pendingStallInstructions(pendingSeconds)
+      }
+    });
+  });
+}
+
+// src/commands/migrate.ts
+var FLOW_MIGRATE_EXAMPLES = [
+  {
+    Description: "Migrate a .flow file to the current schema version",
+    Command: "uip maestro flow migrate ./my-flow/my-flow.flow",
+    Output: {
+      Code: "FlowMigrate",
+      Data: {
+        Migrated: true,
+        FromVersion: "1.0.0",
+        ToVersion: "1.0",
+        WorkflowSteps: ["1.0.0 -> 1.0"]
+      }
+    }
+  },
+  {
+    Description: "Preview changes without writing the file",
+    Command: "uip maestro flow migrate ./my-flow/my-flow.flow --dry-run",
+    Output: {
+      Code: "FlowMigrate",
+      Data: {
+        Migrated: true,
+        DryRun: true,
+        FromVersion: "1.0.0",
+        ToVersion: "1.0",
+        WorkflowSteps: ["1.0.0 -> 1.0"]
+      }
+    }
+  },
+  {
+    Description: "Skip optional node migrations (e.g. typeVersion normalization)",
+    Command: "uip maestro flow migrate ./my-flow/my-flow.flow --no-include-optional",
+    Output: {
+      Code: "FlowMigrate",
+      Data: {
+        Migrated: true,
+        FromVersion: "1.0.0",
+        ToVersion: "1.0",
+        NodeMigrations: { OptionalApplied: 0 }
+      }
+    }
+  }
+];
+var registerMigrateCommand = (program) => {
+  program.command("migrate").description("Migrate a .flow file to the current workflow and node schema versions").argument("<file>", "Path to the .flow file").option("--dry-run", "Show what would change without writing the file").option("--no-include-optional", "Skip optional node migrations (e.g. typeVersion normalization). Default: optional migrations are applied.").examples(FLOW_MIGRATE_EXAMPLES).trackedAction(processContext, async (file, options) => {
+    const { migrateFlow } = await import("./flow-migrate-service-rwcdx60q.js");
+    const [error, result] = await catchError(migrateFlow(file, {
+      dryRun: options.dryRun,
+      includeOptional: options.includeOptional
+    }));
+    if (error) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Failed to migrate flow",
+        Instructions: error.message
+      });
+      processContext.exit(1);
+      return;
+    }
+    const instructions = result.migrated ? result.dryRun ? "Dry-run: file not modified. Re-run without --dry-run to apply." : `Migrated ${result.fromVersion} → ${result.toVersion}` : `Already at version ${result.toVersion}`;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "FlowMigrate",
+      Data: {
+        File: result.file,
+        Migrated: result.migrated,
+        DryRun: result.dryRun,
+        FromVersion: result.fromVersion,
+        ToVersion: result.toVersion,
+        WorkflowSteps: result.workflowSteps,
+        NodeMigrations: {
+          ForcedAvailable: result.forcedNodeMigrations,
+          OptionalAvailable: result.optionalNodeMigrations,
+          OptionalApplied: result.optionalApplied,
+          Failed: result.failedNodeMigrations
+        }
+      },
+      Instructions: instructions
+    });
+  });
+};
+
+// src/commands/node.ts
+var NODE_ADD_EXAMPLES = [
+  {
+    Description: "Add a manual trigger node to a flow",
+    Command: 'uip maestro flow node add flow.json core.trigger.manual --label "Start"',
+    Output: {
+      Code: "NodeAddSuccess",
+      Data: {
+        Node: {
+          id: "node_a1b2c3d4",
+          type: "core.trigger.manual"
+        },
+        DefinitionAdded: true,
+        BindingsCreated: 0,
+        VariableCount: 0
+      }
+    }
+  }
+];
+var NODE_CONFIGURE_EXAMPLES = [
+  {
+    Description: "Configure a connector node with connection details",
+    Command: `uip maestro flow node configure flow.json node_a1b2c3d4 --detail '{"connectionId":"b2c3d4e5-0000-0000-0000-000000000001","folderKey":"c3d4e5f6-0000-0000-0000-000000000001","method":"POST","endpoint":"/issues"}'`,
+    Output: {
+      Code: "NodeConfigureSuccess",
+      Data: {
+        NodeId: "node_a1b2c3d4",
+        BindingsCreated: 2,
+        DetailPopulated: true
+      }
+    }
+  },
+  {
+    Description: "Configure a generic connector activity (e.g. SFDC InsertRecord) — requires objectName",
+    Command: `uip maestro flow node configure flow.json node_a1b2c3d4 --detail '{"connectionId":"b2c3d4e5-0000-0000-0000-000000000001","folderKey":"c3d4e5f6-0000-0000-0000-000000000001","method":"POST","endpoint":"/Account","objectName":"Account","bodyParameters":{"Name":"Acme Corp"}}'`,
+    Output: {
+      Code: "NodeConfigureSuccess",
+      Data: {
+        NodeId: "node_a1b2c3d4",
+        BindingsCreated: 2,
+        DetailPopulated: true
+      }
+    }
+  },
+  {
+    Description: "Configure a param bound to another node's output — must use $vars., not the bare node id",
+    Command: `uip maestro flow node configure flow.json node_a1b2c3d4 --detail '{"connectionId":"b2c3d4e5-0000-0000-0000-000000000001","folderKey":"c3d4e5f6-0000-0000-0000-000000000001","method":"POST","endpoint":"/Account","bodyParameters":{"recordId":"=js:$vars.createEntityRecord1.output.Id"}}'`,
+    Output: {
+      Code: "NodeConfigureSuccess",
+      Data: {
+        NodeId: "node_a1b2c3d4",
+        BindingsCreated: 2,
+        DetailPopulated: true
+      }
+    }
+  }
+];
+var NODE_LIST_EXAMPLES = [
+  {
+    Description: "List all nodes in a flow file",
+    Command: "uip maestro flow node list flow.json",
+    Output: {
+      Code: "NodeListSuccess",
+      Data: {
+        Nodes: [
+          { id: "start", type: "core.trigger.manual" },
+          { id: "node_a1b2c3d4", type: "core.action.http.v2" }
+        ],
+        Count: 2
+      }
+    }
+  }
+];
+var NODE_DELETE_EXAMPLES = [
+  {
+    Description: "Delete a node and its connections from a flow",
+    Command: "uip maestro flow node delete flow.json node_a1b2c3d4",
+    Output: {
+      Code: "NodeDeleteSuccess",
+      Data: {
+        DeletedNode: {
+          id: "node_a1b2c3d4",
+          type: "core.action.http.v2"
+        },
+        EdgesRemoved: 1,
+        BindingsRemoved: 0,
+        DefinitionsRemoved: 0,
+        VariablesRemoved: 0,
+        VariableUpdatesRemoved: 0
+      }
+    }
+  }
+];
+var NODE_REMOVE_EXAMPLES = [
+  {
+    Description: "Remove a node and its connections from a flow",
+    Command: "uip maestro flow node remove flow.json node_a1b2c3d4",
+    Output: {
+      Code: "NodeRemoveSuccess",
+      Data: {
+        DeletedNode: {
+          id: "node_a1b2c3d4",
+          type: "core.action.http.v2"
+        },
+        EdgesRemoved: 1,
+        BindingsRemoved: 0,
+        DefinitionsRemoved: 0,
+        VariablesRemoved: 0,
+        VariableUpdatesRemoved: 0
+      }
+    }
+  }
+];
+function parsePosition2(value) {
+  const parts = value.split(",");
+  if (parts.length !== 2) {
+    throw new Error(`Invalid position format: "${value}". Expected "x,y" (e.g. 250,150)`);
+  }
+  const x = Number(parts[0]);
+  const y = Number(parts[1]);
+  if (Number.isNaN(x) || Number.isNaN(y)) {
+    throw new Error(`Invalid position values: "${value}". x and y must be numbers`);
+  }
+  return { x, y };
+}
+function getDeleteNodeInstructions(file) {
+  return `Check that "${file}" exists and run 'uip maestro flow node list ${file}' to find a valid node ID, then retry.`;
+}
+async function runDeleteNode(file, nodeId, code) {
+  const { deleteNodeFromFlow } = await import("./node-service-8g5x5d2y.js");
+  const normalizedNodeId = nodeId.trim();
+  const [error, result] = await catchError(deleteNodeFromFlow(file, normalizedNodeId));
+  if (error) {
+    OutputFormatter.error({
+      Result: RESULTS.Failure,
+      Message: "Error deleting node",
+      Instructions: getDeleteNodeInstructions(file)
+    });
+    processContext.exit(1);
+    return;
+  }
+  OutputFormatter.success({
+    Result: RESULTS.Success,
+    Code: code,
+    Data: {
+      DeletedNode: result.deletedNode,
+      EdgesRemoved: result.edgesRemoved,
+      BindingsRemoved: result.bindingsRemoved,
+      DefinitionsRemoved: result.definitionsRemoved,
+      VariablesRemoved: result.variablesRemoved,
+      VariableUpdatesRemoved: result.variableUpdatesRemoved
+    }
+  });
+}
+var registerNodeCommand = (program) => {
+  const node = program.command("node").description("Manage nodes in a Flow file");
+  node.command("add").description(`Add a node to a Flow file.
+` + "For connector nodes (type uipath.connector), do NOT pass --input here — " + `run 'node configure' afterwards to supply connection and endpoint details.
+Example: uip maestro flow node add flow.flow uipath.connector.jira.createIssue --label 'Create Jira Issue'`).argument("<file>", "Path to the .flow file").argument("<node-type>", "Node type identifier (e.g. core.trigger.manual)").option("-i, --input <json>", `JSON object of input values to set on the node (e.g. '{"script": "..."}')`).option("--position <x,y>", "Node position in the canvas (e.g. 250,150)").option("--label <label>", "Display label for the node").option("--source <uuid>", "Source UUID for nodes whose manifest declares a source dependency. Use the agent's ProjectId (inline agent nodes) or the resource id from the parent inline agent's resources[] (agent-tool resource nodes). Populates inputs.source.").option("--parent <node-id>", "Id of the existing node that should contain this node. Set when authoring a loop body whose containment cannot be " + "inferred from edges alone — typically the id of a " + "core.logic.loop node.").examples(NODE_ADD_EXAMPLES).trackedAction(processContext, async (file, nodeType, options) => {
+    let inputs;
+    if (options.input !== undefined) {
+      const [parseError, parsed] = catchError(() => JSON.parse(options.input));
+      if (parseError) {
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          Message: "Invalid --input JSON",
+          Instructions: parseError.message
+        });
+        processContext.exit(1);
+        return;
+      }
+      if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          Message: "Invalid --input JSON",
+          Instructions: `--input must be a JSON object (e.g. '{"key": "value"}')`
+        });
+        processContext.exit(1);
+        return;
+      }
+      inputs = parsed;
+    }
+    let position;
+    if (options.position !== undefined) {
+      const [posError, parsed] = catchError(() => parsePosition2(options.position));
+      if (posError) {
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          Message: "Invalid --position value",
+          Instructions: posError.message
+        });
+        processContext.exit(1);
+        return;
+      }
+      position = parsed;
+    }
+    const {
+      addNodeToFlow,
+      NodeTypeNotEnabledError,
+      NodeTypeNotFoundError,
+      SourceRequiredError
+    } = await import("./node-service-8g5x5d2y.js");
+    const [error, result] = await catchError(addNodeToFlow(file, nodeType, {
+      position,
+      label: options.label,
+      inputs,
+      source: options.source,
+      parent: options.parent
+    }));
+    if (error) {
+      if (error instanceof NodeTypeNotEnabledError || error instanceof NodeTypeNotFoundError || error instanceof SourceRequiredError) {
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          Message: error.message,
+          Instructions: error.instructions
+        });
+        processContext.exit(1);
+        return;
+      }
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Error adding node",
+        Instructions: error.message
+      });
+      processContext.exit(1);
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "NodeAddSuccess",
+      Data: {
+        Node: result.node,
+        DefinitionAdded: result.definitionAdded,
+        BindingsCreated: result.bindingsCreated,
+        VariableCount: result.variableCount
+      }
+    });
+  });
+  node.command("configure").description(`Configure a connector or managed HTTP node with connection and method details.
+` + `Run this after 'node add' — populates inputs.detail and creates workflow bindings.
+` + `Use 'node list' to find the node ID.
+
+CONNECTOR ACTIVITIES (type uipath.connector.*, NOT *.trigger.*)
+  Required: connectionId, folderKey, method, endpoint.
+  Generic activities (manifest activityType='Generic', e.g. *.insert-record,
+    *.list-records) also require objectName. Discover with:
+      uip is resources list <connector-key> --operation <op> --connection-id <uuid>
+      uip is resources describe <connector-key> <object> --operation <op> --connection-id <uuid>
+  Curated activities: get method/endpoint from connectorMethodInfo in 'registry get'.
+  Optional: bodyParameters, queryParameters, pathParameters, filter,
+            customFieldsRequestDetails ({ objectActionName, parameterValues: [[k,v],...] });
+  Examples:
+    --detail '{"connectionId":"<uuid>","folderKey":"<uuid>","method":"POST","endpoint":"/issues","bodyParameters":{"summary":"Bug"}}'
+    --detail '{"connectionId":"<uuid>","folderKey":"<uuid>","method":"POST","endpoint":"/Account","objectName":"Account","bodyParameters":{"Name":"Acme"}}'
+  Cross-node bindings (referencing another node's output) require the
+` + `  "$vars." prefix inside the "=js:" expression — the bare form
+` + `  (e.g. "=js:createEntityRecord1.output.Id") resolves to undefined at runtime:
+    --detail '{"connectionId":"<uuid>","folderKey":"<uuid>","method":"POST","endpoint":"/Account","bodyParameters":{"recordId":"=js:$vars.createEntityRecord1.output.Id"}}'
+
+CONNECTOR TRIGGERS (type uipath.connector.trigger.*)
+  Required: connectionId, folderKey, eventMode (e.g. 'polling' or 'webhook').
+  Generic triggers (manifest activityType='GenericTrigger', e.g. Data Fabric
+` + `    *.record-created) also require objectName — the object to subscribe to.
+` + `    Discover with: uip is triggers objects <connector-key> <eventType> --connection-id <uuid>
+  Optional: eventParameters, queryParameters, pathParameters,
+            filter (structured FilterTree, not a raw expression).
+  Discover eventMode with:
+    uip is triggers describe <connector-key> <eventType> <object> --connection-id <uuid>
+  Examples:
+    --detail '{"connectionId":"<uuid>","folderKey":"<uuid>","eventMode":"polling"}'
+    --detail '{"connectionId":"<uuid>","folderKey":"<uuid>","eventMode":"webhooks","objectName":"MyEntity"}'
+
+CONNECTOR WAIT-FOR EVENTS (type uipath.connector.event.*)
+  Mid-flow Receive Task that pauses execution until the event fires.
+` + `  Same detail shape as connector triggers — only activityType differs internally.
+` + `  Required: connectionId, folderKey, eventMode (e.g. 'polling' or 'webhooks').
+  Generic event nodes also require objectName (same rule as triggers).
+  Optional: eventParameters, queryParameters, pathParameters,
+            filter (structured FilterTree, not a raw expression).
+  Discover eventMode with:
+    uip is triggers describe <connector-key> <eventType> <object> --connection-id <uuid>
+  Example:
+    --detail '{"connectionId":"<uuid>","folderKey":"<uuid>","eventMode":"polling","queryParameters":{"repo":"cli"}}'
+
+MANAGED HTTP NODES (type core.action.http.v2)
+` + `  Two authentication modes — set via the 'authentication' key:
+
+` + `  Connector mode (authentication='connector'):
+    Uses an Integration Service connection for auth.
+    Required: authentication, method (GET/POST/PUT/PATCH/DELETE/OPTIONS/HEAD),
+              connectionId (target connector connection UUID),
+              folderKey, targetConnector (e.g. uipath-microsoft-outlook365)
+    Optional: url (path appended to connector base URL), headers, query, body
+    Example:
+      --detail '{"authentication":"connector","targetConnector":"uipath-microsoft-outlook365","connectionId":"<uuid>","folderKey":"<uuid>","method":"GET","url":"/me"}'
+
+  Manual mode (authentication='manual'):
+` + `    No connector auth — provide the full URL and any auth headers yourself.
+` + `    Required: authentication, method, url (full URL)
+    Optional: headers, query, body (string, can be expression e.g. '=js:({...})')
+    Example:
+      --detail '{"authentication":"manual","method":"GET","url":"https://api.example.com/data","headers":{"Authorization":"Bearer <token>"}}'`).argument("<file>", "Path to the .flow file").argument("<node-id>", "ID of the node to configure").option("--detail <json>", "Configuration as JSON (connectionId, folderKey, method, endpoint, objectName for generic activities, bodyParameters, etc.)").examples(NODE_CONFIGURE_EXAMPLES).trackedAction(processContext, async (file, nodeId, options) => {
+    if (!options.detail) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Missing --detail",
+        Instructions: "--detail is required (JSON with connectionId, folderKey, etc.)"
+      });
+      processContext.exit(1);
+      return;
+    }
+    const [parseError, parsed] = catchError(() => JSON.parse(options.detail));
+    if (parseError) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Invalid --detail JSON",
+        Instructions: parseError.message
+      });
+      processContext.exit(1);
+      return;
+    }
+    const { configureConnectorNode, InvalidDetailError } = await import("./connector-service-d9ph9kx1.js");
+    const [error, result] = await catchError(configureConnectorNode(file, nodeId, parsed));
+    if (error) {
+      const message = error instanceof InvalidDetailError ? "Invalid --detail" : "Error configuring node";
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: message,
+        Instructions: error.message
+      });
+      processContext.exit(1);
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "NodeConfigureSuccess",
+      Data: {
+        NodeId: nodeId,
+        BindingsCreated: result.bindingsCreated,
+        DetailPopulated: result.detailPopulated,
+        ...result.warnings && result.warnings.length > 0 && {
+          Warnings: result.warnings
+        }
+      }
+    });
+  });
+  node.command("list").description("List all nodes in a Flow file").argument("<file>", "Path to the .flow file").examples(NODE_LIST_EXAMPLES).trackedAction(processContext, async (file) => {
+    const { listNodesInFlow } = await import("./node-service-8g5x5d2y.js");
+    const [error, result] = await catchError(listNodesInFlow(file));
+    if (error) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Error listing nodes",
+        Instructions: error.message
+      });
+      processContext.exit(1);
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "NodeListSuccess",
+      Data: {
+        Nodes: result.nodes,
+        Count: result.count
+      }
+    });
+  });
+  node.command("delete").description(`Delete a node from a Flow file.
+Automatically removes connected edges, orphaned bindings, orphaned definitions, and node variables owned by the deleted node.
+Use 'node list' to find the node ID.`).argument("<file>", "Path to the .flow file").argument("<node-id>", "ID of the node to delete").examples(NODE_DELETE_EXAMPLES).trackedAction(processContext, async (file, nodeId) => runDeleteNode(file, nodeId, "NodeDeleteSuccess"));
+  node.command("remove").description(`Remove a node from a Flow file.
+Alias for 'node delete'. Automatically removes connected edges, orphaned bindings, orphaned definitions, and node variables owned by the removed node.
+Use 'node list' to find the node ID.`).argument("<file>", "Path to the .flow file").argument("<node-id>", "ID of the node to remove").examples(NODE_REMOVE_EXAMPLES).trackedAction(processContext, async (file, nodeId) => runDeleteNode(file, nodeId, "NodeRemoveSuccess"));
+};
+
+// src/commands/pack.ts
+var FLOW_PACK_EXAMPLES = [
+  {
+    Description: "Pack a flow project into a .nupkg file",
+    Command: "uip maestro flow pack ./my-flow-project ./dist --version 1.2.0",
+    Output: {
+      Code: "FlowPack",
+      Data: {
+        Package: "my-flow-project.1.2.0.nupkg",
+        Output: "./dist/my-flow-project.1.2.0.nupkg"
+      }
+    }
+  }
+];
+var registerPackCommand = (program) => {
+  const command = program.command("pack").description("Pack a Flow project into a .nupkg file").argument("<project-path>", "Path to the Flow project directory").argument("<output-path>", "Output directory where the .nupkg will be saved").option("-n, --name <name>", "Package name (default: project folder name)").option("-v, --version <version>", "Package version (default: 1.0.0)", "1.0.0");
+  registerPackageMetadataOptions(command).examples(FLOW_PACK_EXAMPLES).trackedAction(processContext, async (projectPath, outputPath, options) => {
+    const { FlowPackService } = await import("./flow-pack-service-p4hxyj9e.js");
+    const service = new FlowPackService;
+    const exitCode = await service.execute(projectPath, {
+      output: outputPath,
+      name: options.name,
+      version: options.version,
+      ...mapPackageMetadataOptions(options)
+    });
+    if (exitCode) {
+      processContext.exit(exitCode);
+    }
+  });
+};
+
+// src/commands/process.ts
+var FLOW_PROCESS_LIST_EXAMPLES = [
+  {
+    Description: "List available flow projects in a folder by key",
+    Command: "uip maestro flow process list --folder-key c3d4e5f6-0000-0000-0000-000000000001",
+    Output: {
+      Code: "FlowProjectList",
+      Data: [
+        {
+          name: "InvoiceFlow",
+          processKey: "a1b2c3d4-0000-0000-0000-000000000001:1.0.0",
+          releaseKey: "e5f6a7b8-0000-0000-0000-000000000001",
+          folderKey: "c3d4e5f6-0000-0000-0000-000000000001",
+          feedId: "default",
+          folderId: 42,
+          releaseActive: "Yes",
+          releaseLatest: "Yes"
+        }
+      ]
+    }
+  },
+  {
+    Description: "List available flow projects in a folder by path",
+    Command: 'uip maestro flow process list --folder-path "Shared/Invoices"',
+    Output: {
+      Code: "FlowProjectList",
+      Data: [
+        {
+          name: "InvoiceFlow",
+          processKey: "a1b2c3d4-0000-0000-0000-000000000001:1.0.0",
+          releaseKey: "e5f6a7b8-0000-0000-0000-000000000001",
+          folderKey: "c3d4e5f6-0000-0000-0000-000000000001",
+          feedId: "default",
+          folderId: 42,
+          active: "Yes",
+          latest: "Yes"
+        }
+      ]
+    }
+  }
+];
+var FLOW_PROCESS_GET_EXAMPLES = [
+  {
+    Description: "Get a flow project's entry point schema",
+    Command: "uip maestro flow process get a1b2c3d4-0000-0000-0000-000000000001 default --folder-key c3d4e5f6-0000-0000-0000-000000000001",
+    Output: {
+      Code: "FlowProjectGet",
+      Data: [
+        {
+          Path: "/content/main.flow",
+          DisplayName: "Main",
+          Type: "Flow",
+          InputSchema: '{"type":"object","properties":{}}',
+          OutputSchema: '{"type":"object","properties":{}}'
+        }
+      ]
+    }
+  }
+];
+var FLOW_PROCESS_RUN_EXAMPLES = [
+  {
+    Description: "Run a flow project with JSON inputs",
+    Command: `uip maestro flow process run a1b2c3d4-0000-0000-0000-000000000001 c3d4e5f6-0000-0000-0000-000000000001 --inputs '{"amount":100}'`,
+    Output: {
+      Code: "FlowJobStarted",
+      Data: {
+        jobKey: "b2c3d4e5-0000-0000-0000-000000000001",
+        state: "Pending",
+        traceId: "d4e5f6a7-0000-0000-0000-000000000001",
+        folderKey: "c3d4e5f6-0000-0000-0000-000000000001"
+      }
+    }
+  },
+  {
+    Description: "Run a flow project and bind a local file to a file-typed input variable",
+    Command: "uip maestro flow process run a1b2c3d4-0000-0000-0000-000000000001 c3d4e5f6-0000-0000-0000-000000000001 --attachment file1=./resume.pdf",
+    Output: {
+      Code: "FlowJobStarted",
+      Data: {
+        jobKey: "b2c3d4e5-0000-0000-0000-000000000001",
+        state: "Pending",
+        traceId: "d4e5f6a7-0000-0000-0000-000000000001",
+        folderKey: "c3d4e5f6-0000-0000-0000-000000000001"
+      }
+    }
+  }
+];
+function flowProcessRunErrorCode(error) {
+  return error.message.toLowerCase().includes("release key is required") ? "FlowReleaseKeyRequired" : undefined;
+}
+async function resolveReleaseKey(config, processKey) {
+  const separator = processKey.lastIndexOf(":");
+  const key = separator === -1 ? processKey : processKey.slice(0, separator);
+  const version = separator === -1 ? undefined : processKey.slice(separator + 1);
+  const { listFlowProcesses } = await import("./flow-api-wv8p8xbd.js");
+  const processes = await listFlowProcesses(config);
+  const matches = processes.filter((candidate) => candidate.processKey === key && (version === undefined || candidate.processVersion === version));
+  const [releaseKey, ...extra] = matches.map((match) => match.key).filter((candidate) => Boolean(candidate));
+  if (releaseKey === undefined) {
+    throw new Error(`No Flow release matches process key '${processKey}' in folder ${config.folderKey}.`);
+  }
+  if (extra.length > 0) {
+    throw new Error(`${matches.length} Flow releases match process key '${processKey}' in folder ${config.folderKey}: ${matches.map((match) => `${match.processVersion} (${match.key})`).join(", ")}.`);
+  }
+  return releaseKey;
+}
+async function resolveFolderForList(options) {
+  const { resolveFolder } = await import("./index-ev4mdg5y.js");
+  if (options.folderKey && options.folderPath) {
+    const [pathError, pathFolder] = await catchError(resolveFolder({ folderPath: options.folderPath }, {
+      tenant: options.tenant,
+      loginValidity: options.loginValidity
+    }));
+    if (pathError || !pathFolder) {
+      throw new Error(`Failed to resolve --folder-path '${options.folderPath}': ${pathError?.message ?? "folder not found"}.`);
+    }
+    if (options.folderKey.toLowerCase() !== pathFolder.key.toLowerCase()) {
+      throw new Error(`--folder-key '${options.folderKey}' and --folder-path '${options.folderPath}' refer to different folders. Provide just one, or make them consistent.`);
+    }
+    return options.folderKey;
+  }
+  if (options.folderPath) {
+    const [resolveError, resolved] = await catchError(resolveFolder({ folderPath: options.folderPath }, {
+      tenant: options.tenant,
+      loginValidity: options.loginValidity
+    }));
+    if (resolveError || !resolved) {
+      throw new Error(`Failed to resolve --folder-path '${options.folderPath}': ${resolveError?.message ?? "folder not found"}.`);
+    }
+    return resolved.key;
+  }
+  if (!options.folderKey) {
+    throw new Error("unreachable: folderKey must be defined when folderPath is absent");
+  }
+  return options.folderKey;
+}
+function registerProcessCommand(program) {
+  const processCmd = program.command("process").description("Manage Flow processes");
+  registerSharedProcessCommands(processCmd, { toolLabel: "Flow" });
+  processCmd.command("list").description("List available Flow projects. The releaseActive and releaseLatest fields reflect Orchestrator release-level state (whether the release is marked active or the highest version on the manifest) and do not indicate whether the process is deployed or runnable.").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("--filter <odata>", "Additional OData filter").option("-f, --folder-key <key>", "Folder key (GUID)").option("--folder-path <path>", "Folder path (e.g. 'Shared/Invoices'). Alternative to --folder-key.").option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).examples(FLOW_PROCESS_LIST_EXAMPLES).trackedAction(processContext, async (options) => {
+    const { getLoginStatusAsync } = await import("./index-1kgxzh8x.js");
+    if (options.folderKey === undefined && options.folderPath === undefined) {
+      OutputFormatter.error({
+        Result: RESULTS.ValidationError,
+        Message: "Missing required option --folder-key or --folder-path.",
+        Instructions: "Provide --folder-key <key> or --folder-path <path> and try again."
+      });
+      processContext.exit(3);
+      return;
+    }
+    const [loginError, loginStatus] = await catchError(getLoginStatusAsync({
+      ensureTokenValidityMinutes: options.loginValidity
+    }));
+    if (loginError) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: loginError.message,
+        Instructions: instructionsFor("auth")
+      });
+      processContext.exit(1);
+      return;
+    }
+    if (loginStatus.loginStatus !== "Logged in" || !loginStatus.baseUrl) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Not logged in. Run 'uip login' first.",
+        Instructions: instructionsFor("auth")
+      });
+      processContext.exit(1);
+      return;
+    }
+    const tenantName = options.tenant || loginStatus.tenantName;
+    if (!tenantName) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Tenant not provided and not available from login. Run 'uip login' or 'uip login tenant set <tenant>'.",
+        Instructions: instructionsFor("identity")
+      });
+      processContext.exit(1);
+      return;
+    }
+    if (!loginStatus.organizationId) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Organization ID not available from login.",
+        Instructions: instructionsFor("identity")
+      });
+      processContext.exit(1);
+      return;
+    }
+    const [resolveError, resolvedFolderKey] = await catchError(resolveFolderForList(options));
+    if (resolveError) {
+      OutputFormatter.error({
+        Result: RESULTS.ValidationError,
+        Message: resolveError.message,
+        Instructions: "Provide a valid --folder-key or --folder-path, then retry."
+      });
+      processContext.exit(3);
+      return;
+    }
+    const config = {
+      processKey: "",
+      folderKey: resolvedFolderKey,
+      inputs: {},
+      authToken: loginStatus.accessToken || "",
+      organizationId: loginStatus.organizationId,
+      tenantName,
+      baseUrl: loginStatus.baseUrl
+    };
+    const { listFlowProcesses } = await import("./flow-api-wv8p8xbd.js");
+    const [listError, processes] = await catchError(listFlowProcesses(config, options.filter));
+    if (listError) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: listError.message,
+        Instructions: instructionsFor("backend", listError)
+      });
+      processContext.exit(1);
+      return;
+    }
+    const formattedData = processes.map((p) => ({
+      name: p.name,
+      processKey: `${p.processKey}:${p.processVersion}`,
+      releaseKey: p.key,
+      folderKey: p.folderKey,
+      feedId: p.feedId || "",
+      folderId: p.organizationUnitId || "",
+      releaseActive: p.isActive ? "Yes" : "No",
+      releaseLatest: p.isLatestVersion ? "Yes" : "No"
+    }));
+    OutputFormatter.emitList("FlowProjectList", formattedData, {
+      emptyInstructions: "No Flow projects found. Check folder permissions or try a different folder."
+    });
+  });
+  processCmd.command("get").description("Get Flow project schema and details").argument("<process-key>", "Process key (e.g., MyFlow.flow.Flow:1.0.0)").argument("<feed-id>", "Feed ID (from 'flow project list')").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).requiredOption("-f, --folder-key <key>", "Folder key (GUID)").option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).examples(FLOW_PROCESS_GET_EXAMPLES).trackedAction(processContext, async (processKey, feedId, options) => {
+    const { getLoginStatusAsync } = await import("./index-1kgxzh8x.js");
+    const [loginError, loginStatus] = await catchError(getLoginStatusAsync({
+      ensureTokenValidityMinutes: options.loginValidity
+    }));
+    if (loginError) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: loginError.message,
+        Instructions: instructionsFor("auth")
+      });
+      processContext.exit(1);
+      return;
+    }
+    if (loginStatus.loginStatus !== "Logged in" || !loginStatus.baseUrl) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Not logged in. Run 'uip login' first.",
+        Instructions: instructionsFor("auth")
+      });
+      processContext.exit(1);
+      return;
+    }
+    const tenantName = options.tenant || loginStatus.tenantName;
+    if (!tenantName) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Tenant not provided and not available from login. Run 'uip login' or 'uip login tenant set <tenant>'.",
+        Instructions: instructionsFor("identity")
+      });
+      processContext.exit(1);
+      return;
+    }
+    if (!loginStatus.organizationId) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Organization ID not available from login.",
+        Instructions: instructionsFor("identity")
+      });
+      processContext.exit(1);
+      return;
+    }
+    const config = {
+      processKey,
+      folderKey: options.folderKey,
+      inputs: {},
+      authToken: loginStatus.accessToken || "",
+      organizationId: loginStatus.organizationId,
+      tenantName,
+      baseUrl: loginStatus.baseUrl,
+      feedId
+    };
+    const { getFlowEntryPoints } = await import("./flow-api-wv8p8xbd.js");
+    const [entryPointsError, entryPoints] = await catchError(getFlowEntryPoints(config));
+    if (entryPointsError) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: entryPointsError.message,
+        Instructions: instructionsFor("backend", entryPointsError)
+      });
+      processContext.exit(1);
+      return;
+    }
+    if (entryPoints.length === 0) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "No entry points found for this process.",
+        Instructions: "Verify the process key is correct and published."
+      });
+      processContext.exit(1);
+      return;
+    }
+    const formattedData = entryPoints.map((ep) => {
+      const [, inputSchema] = catchError(() => JSON.parse(ep.InputArguments));
+      const [, outputSchema] = catchError(() => JSON.parse(ep.OutputArguments));
+      return {
+        Path: ep.Path,
+        DisplayName: ep.DisplayName,
+        Type: ep.Type,
+        InputSchema: JSON.stringify(inputSchema ?? {}, null, 2),
+        OutputSchema: JSON.stringify(outputSchema ?? {}, null, 2)
+      };
+    });
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "FlowProjectGet",
+      Data: formattedData,
+      Instructions: `Found ${entryPoints.length} entry point(s) for ${processKey}`
+    });
+  });
+  processCmd.command("run").description("Run a Flow project with inputs").argument("<process-key>", "Process key (e.g., MyFlow.flow.Flow:1.0.0)").argument("<folder-key>", "Folder key (GUID)").option("-i, --inputs <json>", "Input parameters as JSON string or @file.json").option("--attachment <name=path>", "Upload a local file as a file-typed workflow input variable (repeatable). Example: --attachment file1=./resume.pdf", appendOption, []).addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("--release-key <key>", "Release key (GUID, from list command)").option("--feed-id <id>", "Feed ID for package lookup (optional)").option("--robot-ids <ids>", "Comma-separated robot IDs (optional)").option("--validate", "Validate inputs against project schema (basic: required fields + primitive types)").option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).option("--wait", "Block until the job reaches a terminal state (Successful, Faulted, Stopped)").option("--timeout <seconds>", "Maximum seconds to wait (0 = no timeout). Requires --wait.", String(DEFAULT_TIMEOUT_MS / 1000)).option("--poll-interval <seconds>", "Seconds between status checks. Requires --wait.", String(DEFAULT_INTERVAL_MS / 1000)).examples(FLOW_PROCESS_RUN_EXAMPLES).trackedAction(processContext, async (processKey, folderKey, options) => {
+    const { getLoginStatusAsync } = await import("./index-1kgxzh8x.js");
+    const {
+      parseFlowInputs,
+      startFlowProjectJob,
+      validateFlowInputs
+    } = await import("./flow-api-wv8p8xbd.js");
+    const [loginError, loginStatus] = await catchError(getLoginStatusAsync({
+      ensureTokenValidityMinutes: options.loginValidity
+    }));
+    if (loginError) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: loginError.message,
+        Instructions: instructionsFor("auth")
+      });
+      processContext.exit(1);
+      return;
+    }
+    if (loginStatus.loginStatus !== "Logged in" || !loginStatus.baseUrl) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Not logged in. Run 'uip login' first.",
+        Instructions: instructionsFor("auth")
+      });
+      processContext.exit(1);
+      return;
+    }
+    const tenantName = options.tenant || loginStatus.tenantName;
+    if (!tenantName) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Tenant not provided and not available from login. Run 'uip login' or 'uip login tenant set <tenant>'.",
+        Instructions: instructionsFor("identity")
+      });
+      processContext.exit(1);
+      return;
+    }
+    if (!loginStatus.organizationId) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Organization ID not available from login.",
+        Instructions: instructionsFor("identity")
+      });
+      processContext.exit(1);
+      return;
+    }
+    let inputs = {};
+    if (options.inputs) {
+      const [parseError, parsed] = await catchError(parseFlowInputs(options.inputs));
+      if (parseError) {
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          Message: parseError.message,
+          Instructions: instructionsFor("input-parse")
+        });
+        processContext.exit(1);
+        return;
+      }
+      inputs = parsed;
+    } else {
+      const { readStdin } = await import("./input-reader-6pwhtp8v.js");
+      const [stdinError, stdinData] = await catchError(readStdin());
+      if (stdinError) {
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          Message: stdinError.message,
+          Instructions: instructionsFor("input-parse")
+        });
+        processContext.exit(1);
+        return;
+      }
+      if (stdinData) {
+        const [parseError, parsed] = await catchError(parseFlowInputs(stdinData));
+        if (parseError) {
+          OutputFormatter.error({
+            Result: RESULTS.Failure,
+            Message: parseError.message,
+            Instructions: instructionsFor("input-parse")
+          });
+          processContext.exit(1);
+          return;
+        }
+        inputs = parsed;
+      }
+    }
+    const attachmentSpecs = options.attachment ?? [];
+    if (attachmentSpecs.length > 0) {
+      const [parseError, specs] = catchError(() => attachmentSpecs.map(parseAttachmentSpec));
+      if (parseError) {
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          Message: parseError.message,
+          Instructions: ATTACHMENT_INSTRUCTIONS
+        });
+        processContext.exit(1);
+        return;
+      }
+      const { uploadJobAttachment } = await import("./index-ev4mdg5y.js");
+      const [uploadError, resolved] = await catchError(resolveAttachmentInputs(specs, (bytes, fileName) => uploadJobAttachment(bytes, fileName, {
+        tenant: tenantName
+      })));
+      if (uploadError) {
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          Message: uploadError.message,
+          Instructions: ATTACHMENT_UPLOAD_INSTRUCTIONS
+        });
+        processContext.exit(1);
+        return;
+      }
+      for (const { name, path, reference } of resolved) {
+        if (name in inputs) {
+          logger.warn(`--attachment '${name}' overrides the value provided in --inputs.`);
+        }
+        inputs[name] = reference;
+        logger.info(`Uploaded '${path}' as attachment ${reference.ID} (variable '${name}').`);
+      }
+    }
+    const config = {
+      processKey,
+      folderKey,
+      inputs,
+      authToken: loginStatus.accessToken || "",
+      organizationId: loginStatus.organizationId,
+      tenantName,
+      tenantId: loginStatus.tenantId,
+      baseUrl: loginStatus.baseUrl,
+      releaseKey: options.releaseKey,
+      feedId: options.feedId
+    };
+    if (options.robotIds) {
+      config.robotIds = options.robotIds.split(",").map((id) => parseInt(id.trim(), 10));
+      if (config.robotIds.some((id) => Number.isNaN(id))) {
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          Message: `Invalid robot-ids: ${options.robotIds}. Must be comma-separated numbers.`,
+          Instructions: instructionsFor("flag-format")
+        });
+        processContext.exit(1);
+        return;
+      }
+    }
+    if (options.validate) {
+      const [valError, validation] = await catchError(validateFlowInputs(config, inputs));
+      if (valError) {
+        const code = flowProcessRunErrorCode(valError);
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          ...code ? { Code: code } : {},
+          Message: valError.message,
+          Instructions: instructionsFor("backend", valError)
+        });
+        processContext.exit(1);
+        return;
+      }
+      if (!validation.valid) {
+        const validationErrors = validation.errors ?? [];
+        const errorList = validationErrors.length > 0 ? validationErrors.map((error) => `- ${error}`).join(`
+`) : "No validation details returned.";
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          Message: `Input validation failed:
+${errorList}`,
+          Instructions: instructionsFor("input-validate")
+        });
+        processContext.exit(1);
+        return;
+      }
+      logger.info("✅ Input validation passed");
+    }
+    let timeoutMs;
+    let intervalMs;
+    if (options.wait) {
+      const timeoutS = Number(options.timeout);
+      const intervalS = Number(options.pollInterval);
+      if (!Number.isFinite(timeoutS) || timeoutS < 0) {
+        OutputFormatter.error({
+          Result: "Failure",
+          Message: `Invalid --timeout value: '${options.timeout}'. Must be a non-negative number.`,
+          Instructions: "Pass seconds, e.g. --timeout 300"
+        });
+        processContext.exit(1);
+        return;
+      }
+      if (!Number.isFinite(intervalS) || intervalS <= 0) {
+        OutputFormatter.error({
+          Result: "Failure",
+          Message: `Invalid --poll-interval value: '${options.pollInterval}'. Must be a positive number.`,
+          Instructions: "Pass seconds, e.g. --poll-interval 10"
+        });
+        processContext.exit(1);
+        return;
+      }
+      timeoutMs = timeoutS * 1000;
+      intervalMs = intervalS * 1000;
+    }
+    if (config.releaseKey === undefined) {
+      const [resolveError, resolvedReleaseKey] = await catchError(resolveReleaseKey(config, processKey));
+      if (resolveError) {
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          Code: "FlowReleaseKeyRequired",
+          Message: resolveError.message,
+          Instructions: `Run 'uip maestro flow process list --folder-key ${folderKey}' and pass the matching releaseKey as --release-key.`
+        });
+        processContext.exit(1);
+        return;
+      }
+      config.releaseKey = resolvedReleaseKey;
+      logger.info(`Resolved --release-key ${resolvedReleaseKey} for process ${processKey}.`);
+    }
+    const [jobError, job] = await catchError(startFlowProjectJob(config));
+    if (jobError) {
+      const code = flowProcessRunErrorCode(jobError);
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        ...code ? { Code: code } : {},
+        Message: jobError.message,
+        Instructions: instructionsFor("backend", jobError)
+      });
+      processContext.exit(1);
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "FlowJobStarted",
+      Data: {
+        jobKey: job.key,
+        state: job.state,
+        traceId: job.traceId,
+        folderKey
+      },
+      Instructions: `Watch traces: uip maestro flow job traces ${job.key} --folder-key ${folderKey}`
+    });
+    if (!options.wait) {
+      processContext.exit(0);
+      return;
+    }
+    if (!job.key) {
+      OutputFormatter.error({
+        Result: "Failure",
+        Message: "Job started but no key returned — cannot wait",
+        Instructions: "Check the job in Orchestrator or retry without --wait."
+      });
+      processContext.exit(1);
+      return;
+    }
+    const { handleFlowJobWait } = await import("./wait-for-flow-job-45p1a444.js");
+    await handleFlowJobWait(job.key, {
+      config,
+      timeoutMs,
+      intervalMs
+    });
+  });
+}
+
+// src/commands/processes.ts
+var registerProcessesCommand = (program) => {
+  registerSharedProcessesCommands(program, {
+    toolLabel: "Flow",
+    processType: "Flow"
+  });
+};
+
+// src/commands/publish.ts
+var FLOW_PUBLISH_EXAMPLES = [
+  {
+    Description: "Pack and publish a Flow project to Orchestrator",
+    Command: "uip maestro flow publish ./my-flow-project --version 1.2.0",
+    Output: {
+      Code: "FlowPublish",
+      Data: {
+        Package: "my-flow-project@1.2.0",
+        PackagePath: "/tmp/flow-publish-1710000000000/my-flow-project.flow.Flow.1.2.0.nupkg",
+        Upload: [
+          {
+            key: "my-flow-project.flow.Flow.1.2.0.nupkg",
+            status: "Created"
+          }
+        ]
+      }
+    }
+  }
+];
+function getDefaultOutputPath(fs = getFileSystem()) {
+  return fs.path.join(fs.env.tmpdir(), `flow-publish-${Date.now()}`);
+}
+var registerPublishCommand = (program) => {
+  program.command("publish").description("Pack a Flow project and upload the resulting .nupkg to Orchestrator packages").argument("<project-path>", "Path to the Flow project directory").argument("[output-path]", "Output directory where the generated .nupkg will be saved").option("-n, --name <name>", "Package name (default: project folder name)").option("-v, --version <version>", "Package version (default: 1.0.0)", "1.0.0").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("--feed-id <feedId>", "Feed ID (optional, defaults to tenant feed). Mutually exclusive with --folder-key/--folder-path.").option("--folder-key <key>", "Folder key (GUID) of an Orchestrator folder hierarchy feed. The CLI resolves the folder's feed ID automatically. Mutually exclusive with --feed-id and --folder-path.").option("--folder-path <path>", "Folder path (e.g. 'Shared/Sub') of an Orchestrator folder hierarchy feed. The CLI resolves the folder's feed ID automatically. Mutually exclusive with --feed-id and --folder-key.").examples(FLOW_PUBLISH_EXAMPLES).trackedAction(processContext, async (projectPath, outputPath, options) => {
+    const { getLoginStatusAsync } = await import("./index-1kgxzh8x.js");
+    const {
+      createApiClient,
+      PackageFeedsApi,
+      ProcessesApi,
+      resolveFolder
+    } = await import("./index-ev4mdg5y.js");
+    const fs = getFileSystem();
+    const shouldCleanupOutput = outputPath === undefined;
+    const packageOutputPath = outputPath ?? getDefaultOutputPath(fs);
+    try {
+      const [loginError, loginStatus] = await catchError(getLoginStatusAsync());
+      if (loginError) {
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          Message: loginError.message,
+          Instructions: instructionsFor("auth", loginError)
+        });
+        processContext.exit(1);
+        return;
+      }
+      if (loginStatus.loginStatus !== "Logged in" || !loginStatus.baseUrl) {
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          Message: "Not logged in. Run 'uip login' first.",
+          Instructions: instructionsFor("auth")
+        });
+        processContext.exit(1);
+        return;
+      }
+      const folderTargetingSpecified = options.folderKey !== undefined || options.folderPath !== undefined;
+      if (folderTargetingSpecified && options.feedId) {
+        OutputFormatter.error({
+          Result: RESULTS.ValidationError,
+          Message: "Cannot combine --feed-id with --folder-key/--folder-path.",
+          Instructions: "Pass either --feed-id (raw feed) or --folder-key/--folder-path (the CLI resolves the feed) — not both."
+        });
+        processContext.exit(3);
+        return;
+      }
+      if (options.folderKey !== undefined && options.folderPath !== undefined) {
+        OutputFormatter.error({
+          Result: RESULTS.ValidationError,
+          Message: "Cannot combine --folder-key with --folder-path.",
+          Instructions: "Pass either --folder-key or --folder-path to identify the folder feed — not both."
+        });
+        processContext.exit(3);
+        return;
+      }
+      let resolvedFeedId = options.feedId;
+      if (folderTargetingSpecified) {
+        const [folderError, folder] = await catchError(resolveFolder({
+          folderKey: options.folderKey,
+          folderPath: options.folderPath
+        }, { tenant: options.tenant }));
+        if (folderError || !folder) {
+          const message = folderError ? `Could not resolve folder: ${folderError.message}` : "Folder targeting requested but no folder resolved.";
+          OutputFormatter.error({
+            Result: RESULTS.ValidationError,
+            Message: message,
+            Instructions: "Provide a valid --folder-key or --folder-path. Use 'uip or folders list' to confirm the key or path."
+          });
+          processContext.exit(3);
+          return;
+        }
+        const [feedsApiError, feedsApi] = await catchError(createApiClient(PackageFeedsApi, {
+          tenant: options.tenant
+        }));
+        if (feedsApiError) {
+          OutputFormatter.error({
+            Result: RESULTS.Failure,
+            Message: "Flow publish failed",
+            Instructions: "Could not create the feeds API client. Re-authenticate and verify the tenant name before trying again."
+          });
+          processContext.exit(1);
+          return;
+        }
+        const [feedLookupError, folderFeedId] = await catchError(feedsApi.packageFeedsGetFolderFeed({
+          folderId: folder.id
+        }));
+        if (feedLookupError || !folderFeedId) {
+          const detail = feedLookupError ? await extractErrorMessage(feedLookupError) : "Folder has no associated package feed.";
+          OutputFormatter.error({
+            Result: RESULTS.Failure,
+            Message: `Could not resolve folder feed for '${folder.path}': ${detail}`,
+            Instructions: "Confirm the folder has FeedType 'FolderHierarchy' (see 'uip or folders get'). Tenant-scoped folders use the default tenant feed and don't need folder targeting."
+          });
+          processContext.exit(1);
+          return;
+        }
+        resolvedFeedId = folderFeedId;
+      }
+      const { FlowPackService } = await import("./flow-pack-service-p4hxyj9e.js");
+      const service = new FlowPackService;
+      const [packError, packResult] = await catchError(service.executeAsync(projectPath, {
+        output: packageOutputPath,
+        name: options.name,
+        version: options.version
+      }));
+      if (packError) {
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          Message: `Flow publish failed: ${packError.message}`,
+          Instructions: "Fix the Flow project packaging error and run the command again."
+        });
+        processContext.exit(1);
+        return;
+      }
+      if (!packResult.success || !packResult.outputPath) {
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          Message: `Flow publish failed: ${packResult.message || "Could not pack the Flow project."}`,
+          Instructions: "Fix the Flow project packaging error and run the command again."
+        });
+        processContext.exit(1);
+        return;
+      }
+      const [apiError, api] = await catchError(createApiClient(ProcessesApi, {
+        tenant: options.tenant
+      }));
+      if (apiError) {
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          Message: "Flow publish failed",
+          Instructions: "Authenticate with 'uip auth login' and verify the tenant name before trying again."
+        });
+        processContext.exit(1);
+        return;
+      }
+      const [readError, fileBuffer] = await catchError(fs.readFile(packResult.outputPath));
+      if (readError) {
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          Message: `Flow publish failed: ${readError.message}`,
+          Instructions: `Verify the generated package exists at '${packResult.outputPath}' and that the current user can read it.`
+        });
+        processContext.exit(1);
+        return;
+      }
+      const fileName = fs.path.basename(packResult.outputPath);
+      const file = new File([fileBuffer], fileName, {
+        type: "application/octet-stream"
+      });
+      const [uploadError, uploadResult] = await catchError(api.processesUploadPackage({
+        file,
+        feedId: resolvedFeedId
+      }));
+      if (uploadError) {
+        const errorMessage = await extractErrorMessage(uploadError);
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          Message: `Flow package upload failed: ${errorMessage}`,
+          Instructions: "Verify the tenant or feed ID, confirm you have package upload permissions, and retry with a new package version if the version already exists."
+        });
+        processContext.exit(1);
+        return;
+      }
+      const shipped = packResult.packageName ? splitPackagedName(packResult.packageName) : undefined;
+      trackShipSucceeded({
+        ship_kind: "publish",
+        target: folderTargetingSpecified ? "orchestrator_folder_package_feed" : resolvedFeedId ? "orchestrator_package_feed" : "orchestrator_tenant_package_feed",
+        project_type: "flow",
+        command_name: "uip.flow.publish",
+        ...shipped ? { package_name: shipped.name } : {},
+        ...shipped?.version ? { package_version: shipped.version } : {}
+      });
+      OutputFormatter.success({
+        Result: RESULTS.Success,
+        Code: "FlowPublish",
+        Data: {
+          Package: packResult.packageName ?? "",
+          PackagePath: packResult.outputPath,
+          Upload: uploadResult.value ?? []
+        }
+      });
+    } finally {
+      if (shouldCleanupOutput) {
+        await catchError(fs.rm(packageOutputPath));
+      }
+    }
+  });
+};
+
+// src/commands/registry.ts
+var registerRegistryCommand2 = (program) => {
+  registerRegistryCommand(program, "maestro flow");
+};
+
+// src/commands/tidy.ts
+var registerTidyCommand = (program) => {
+  program.command("format").description("Format a .flow file by auto-laying out nodes to prevent overlaps and arrange in a clean flow").argument("<file>", "Path to the .flow file").trackedAction(processContext, async (file) => {
+    const { tidyFlow } = await import("./tidy-service-ashgyfwj.js");
+    const [error, result] = await catchError(tidyFlow(file));
+    if (error) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Failed to tidy flow",
+        Instructions: error.message
+      });
+      processContext.exit(1);
+      return;
+    }
+    const changes = [];
+    if (result.nodesRepositioned > 0) {
+      changes.push(`Repositioned ${result.nodesRepositioned} of ${result.nodeCount} nodes`);
+    }
+    if (result.nodesResized > 0) {
+      changes.push(`Set canonical size on ${result.nodesResized} node(s)`);
+    }
+    if (result.subflowsTidied > 0) {
+      changes.push(`Tidied ${result.subflowsTidied} subflow(s)`);
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "FlowFormat",
+      Data: {
+        File: file,
+        NodesTotal: result.nodeCount,
+        EdgesTotal: result.edgeCount,
+        NodesRepositioned: result.nodesRepositioned,
+        NodesResized: result.nodesResized,
+        SubflowsTidied: result.subflowsTidied,
+        VariableCount: result.variableCount
+      },
+      Instructions: changes.length > 0 ? changes.join(". ") : "All nodes already in optimal positions"
+    });
+  });
+};
+
+// src/commands/validate.ts
+var STRICT_EXPRESSIONS_DEFAULT = false;
+var FLOW_VALIDATE_EXAMPLES = [
+  {
+    Description: "Validate a .flow file against the flow schema",
+    Command: "uip maestro flow validate flow.json",
+    Output: {
+      Code: "FlowValidate",
+      Data: {
+        File: "flow.json",
+        Status: "Valid"
+      }
+    }
+  },
+  {
+    Description: "Validate with governance policy checks (requires login)",
+    Command: "uip maestro flow validate flow.json --governance",
+    Output: {
+      Code: "FlowValidate",
+      Data: {
+        File: "flow.json",
+        Status: "Valid"
+      }
+    }
+  },
+  {
+    Description: "Treat connector-shaped Managed HTTP nodes without a binding as errors (CI-grade gate)",
+    Command: "uip maestro flow validate flow.json --strict-bindings",
+    Output: {
+      Code: "FlowValidate",
+      Data: {
+        File: "flow.json",
+        Status: "Valid"
+      }
+    }
+  },
+  {
+    Description: "Validate a project directory — resolves the project's .flow (project.uiproj MainFile)",
+    Command: "uip maestro flow validate ./my-flow-project",
+    Output: {
+      Code: "FlowValidate",
+      Data: {
+        File: "my-flow-project/Main.flow",
+        Status: "Valid"
+      }
+    }
+  },
+  {
+    Description: "Fail validation on expression and script type errors (they are warnings by default)",
+    Command: "uip maestro flow validate flow.json --strict-expressions",
+    Output: {
+      Code: "FlowValidate",
+      Data: {
+        File: "flow.json",
+        Status: "Valid"
+      }
+    }
+  }
+];
+var registerValidateCommand = (program) => {
+  program.command("validate").description("Validate a .flow file (or a project directory containing one) against the Flow schema").argument("<flowFile>", "Path to the .flow file (or a project directory containing one) to validate").option("--governance", "Validate agent nodes against organization governance policies (requires login)").option("--strict-bindings", "Fail validation when a Managed HTTP node (core.action.http.v2) carries a connector-shaped label but no Integration Service binding. Default: warn only.").option("--strict-expressions", "Fail validation when an expression or script body has a type error. The check always runs, using the shared Flow expression checker (the same engine the canvas runs); its findings are warnings by default. Default: warn only.").examples(FLOW_VALIDATE_EXAMPLES).trackedAction(processContext, async (flowFile, options) => {
+    let governanceEnforcements;
+    let availableModelNames;
+    if (options.governance) {
+      const { fetchGovernanceData } = await import("./governance-fetcher-j9cx4f1d.js");
+      const [error, data] = await catchError(fetchGovernanceData());
+      if (error) {
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          Message: `Could not fetch governance data: ${error.message}`,
+          Instructions: "Ensure you are logged in and the platform is reachable, or omit --governance to skip policy checks."
+        });
+        processContext.exit(1);
+        return;
+      }
+      governanceEnforcements = data.enforcements;
+      availableModelNames = data.modelNames;
+    }
+    const { FlowValidateService } = await import("./flow-validate-service-j25pxpwz.js");
+    const service = new FlowValidateService({
+      governanceEnforcements,
+      availableModelNames,
+      validateCurrentManifests: true,
+      strictBindings: options.strictBindings === true,
+      strictExpressions: options.strictExpressions ?? STRICT_EXPRESSIONS_DEFAULT
+    });
+    const exitCode = await service.execute(flowFile);
+    if (exitCode) {
+      processContext.exit(exitCode);
+    }
+  });
+};
+
+// src/commands/variable.ts
+var VARIABLE_ADD_EXAMPLES = [
+  {
+    Description: "Add a string input variable to a flow (auto-bound to the flow's trigger node, making it an entry-point input)",
+    Command: "uip maestro flow variable add flow.json myInput --direction in --type string",
+    Output: {
+      Code: "VariableAddSuccess",
+      Data: {
+        Variable: {
+          id: "myInput",
+          direction: "in",
+          type: "string",
+          triggerNodeId: "manualTrigger1"
+        }
+      }
+    }
+  },
+  {
+    Description: "Bind an input to a specific trigger when the flow has several entry points",
+    Command: "uip maestro flow variable add flow.json myInput --direction in --type string --trigger-node-id timerTrigger1",
+    Output: {
+      Code: "VariableAddSuccess",
+      Data: {
+        Variable: {
+          id: "myInput",
+          direction: "in",
+          type: "string",
+          triggerNodeId: "timerTrigger1"
+        }
+      }
+    }
+  }
+];
+var VARIABLE_DELETE_EXAMPLES = [
+  {
+    Description: "Remove a variable from a flow",
+    Command: "uip maestro flow variable remove flow.json myInput",
+    Output: {
+      Code: "VariableRemoveSuccess",
+      Data: {
+        DeletedVariable: {
+          id: "myInput",
+          direction: "in",
+          type: "string"
+        }
+      }
+    }
+  }
+];
+var VARIABLE_LIST_EXAMPLES = [
+  {
+    Description: "List all variables in a flow file",
+    Command: "uip maestro flow variable list flow.json",
+    Output: {
+      Code: "VariableListSuccess",
+      Data: {
+        Variables: [
+          { id: "myInput", direction: "in", type: "string" },
+          { id: "result", direction: "out", type: "object" }
+        ],
+        Count: 2
+      }
+    }
+  }
+];
+var VALID_TYPES = ["string", "number", "boolean", "object", "array", "file"];
+var VALID_DIRECTIONS = ["in", "out", "inout"];
+function parseDefaultValue(value, type) {
+  switch (type) {
+    case "string":
+      return { parsed: value };
+    case "number": {
+      const num = parseFloat(value);
+      if (Number.isNaN(num)) {
+        return {
+          error: `Invalid default value for type 'number': '${value}'`
+        };
+      }
+      return { parsed: num };
+    }
+    case "boolean": {
+      if (value !== "true" && value !== "false") {
+        return {
+          error: `Invalid default value for type 'boolean': '${value}'. Must be 'true' or 'false'`
+        };
+      }
+      return { parsed: value === "true" };
+    }
+    case "object":
+    case "array": {
+      const [parseErr, parsedValue] = catchError(() => JSON.parse(value));
+      if (parseErr) {
+        return {
+          error: `Invalid default value for type '${type}': must be valid JSON`
+        };
+      }
+      if (type === "object" && (typeof parsedValue !== "object" || parsedValue === null || Array.isArray(parsedValue))) {
+        return {
+          error: `Invalid default value for type 'object': must be a JSON object`
+        };
+      }
+      if (type === "array" && !Array.isArray(parsedValue)) {
+        return {
+          error: `Invalid default value for type 'array': must be a JSON array`
+        };
+      }
+      return { parsed: parsedValue };
+    }
+    default:
+      return { parsed: value };
+  }
+}
+var registerVariableCommand = (program) => {
+  const variable = program.command("variable").description("Manage variables in a Flow file");
+  variable.command("add").description("Add a variable to a Flow file").argument("<file>", "Path to the .flow file").argument("<variable-id>", "Variable identifier (e.g. myInputVar)").requiredOption("-d, --direction <direction>", `Variable direction (${VALID_DIRECTIONS.join(", ")})`).option("-t, --type <type>", `Data type (${VALID_TYPES.join(", ")})`, "string").option("--default-value <value>", "Default value (parsed based on --type)").option("--description <text>", "Human-readable description").option("--schema <json>", "JSON schema for object/array types").option("--sub-type <subType>", "Sub-type for complex types").option("--trigger-node-id <nodeId>", "Trigger node an input variable belongs to (defaults to the flow's only trigger node; required when the flow has several)").examples(VARIABLE_ADD_EXAMPLES).trackedAction(processContext, async (file, variableId, options) => {
+    const { validateIdentifier } = await import("./index-4zrwgb3c.js");
+    const identifierError = validateIdentifier(variableId, []);
+    if (identifierError) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: `Invalid variable id '${variableId}'`,
+        Instructions: identifierError
+      });
+      processContext.exit(1);
+      return;
+    }
+    if (!VALID_DIRECTIONS.includes(options.direction)) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: `Invalid --direction '${options.direction}'`,
+        Instructions: `Must be one of: ${VALID_DIRECTIONS.join(", ")}`
+      });
+      processContext.exit(1);
+      return;
+    }
+    if (!VALID_TYPES.includes(options.type)) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: `Invalid --type '${options.type}'`,
+        Instructions: `Must be one of: ${VALID_TYPES.join(", ")}`
+      });
+      processContext.exit(1);
+      return;
+    }
+    let defaultValue;
+    if (options.defaultValue !== undefined) {
+      const result = parseDefaultValue(options.defaultValue, options.type);
+      if ("error" in result) {
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          Message: result.error,
+          Instructions: "Provide a valid default value for the specified type"
+        });
+        processContext.exit(1);
+        return;
+      }
+      defaultValue = result.parsed;
+    }
+    let schema;
+    if (options.schema !== undefined) {
+      const [parseError, parsed] = catchError(() => JSON.parse(options.schema));
+      if (parseError) {
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          Message: "Invalid --schema JSON",
+          Instructions: parseError.message
+        });
+        processContext.exit(1);
+        return;
+      }
+      if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          Message: "Invalid --schema value",
+          Instructions: `--schema must be a JSON object (e.g. '{"type": "string"}')`
+        });
+        processContext.exit(1);
+        return;
+      }
+      schema = parsed;
+    }
+    const { addVariableToFlow } = await import("./variable-service-er7ph4br.js");
+    const [error, variable2] = await catchError(addVariableToFlow(file, {
+      id: variableId,
+      direction: options.direction,
+      type: options.type,
+      subType: options.subType,
+      defaultValue,
+      description: options.description,
+      schema,
+      triggerNodeId: options.triggerNodeId
+    }));
+    if (error) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Error adding variable",
+        Instructions: error.message
+      });
+      processContext.exit(1);
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "VariableAddSuccess",
+      Data: {
+        Variable: variable2
+      }
+    });
+  });
+  variable.command("remove").description("Remove a variable from a Flow file").argument("<file>", "Path to the .flow file").argument("<variable-id>", "Variable identifier to remove").examples(VARIABLE_DELETE_EXAMPLES).trackedAction(processContext, async (file, variableId) => {
+    const { validateIdentifier } = await import("./index-4zrwgb3c.js");
+    const identifierError = validateIdentifier(variableId, []);
+    if (identifierError) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: `Invalid variable id '${variableId}'`,
+        Instructions: identifierError
+      });
+      processContext.exit(1);
+      return;
+    }
+    const { deleteVariableFromFlow } = await import("./variable-service-er7ph4br.js");
+    const [error, deletedVariable] = await catchError(deleteVariableFromFlow(file, variableId));
+    if (error) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Error deleting variable",
+        Instructions: error.message
+      });
+      processContext.exit(1);
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "VariableRemoveSuccess",
+      Data: {
+        DeletedVariable: deletedVariable
+      }
+    });
+  });
+  variable.command("list").description("List all variables in a Flow file").argument("<file>", "Path to the .flow file").examples(VARIABLE_LIST_EXAMPLES).trackedAction(processContext, async (file) => {
+    const { listVariablesInFlow } = await import("./variable-service-er7ph4br.js");
+    const [error, result] = await catchError(listVariablesInFlow(file));
+    if (error) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Error listing variables",
+        Instructions: error.message
+      });
+      processContext.exit(1);
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "VariableListSuccess",
+      Data: {
+        Variables: result.variables,
+        Count: result.count
+      }
+    });
+  });
+};
+
+// src/services/project-metadata-reader.ts
+async function readAgentProjectMetadata(projectDir) {
+  const fs = getFileSystem();
+  const [readError, content] = await catchError(fs.readFile(fs.path.join(projectDir, "agent.json"), "utf-8"));
+  if (readError || typeof content !== "string") {
+    logger.debug(`No readable agent.json in ${projectDir}; the node will describe an autonomous agent.`);
+    return {};
+  }
+  const [parseError, parsed] = catchError(() => JSON.parse(content));
+  if (parseError) {
+    logger.debug(`Unparseable agent.json in ${projectDir}: ${parseError.message}. The node will describe an autonomous agent.`);
+    return {};
+  }
+  const metadata = {};
+  const isConversational = parsed.metadata?.isConversational;
+  if (typeof isConversational === "boolean") {
+    metadata.isConversational = isConversational;
+  }
+  const targetRuntime = parsed.metadata?.targetRuntime;
+  if (typeof targetRuntime === "string") {
+    metadata.targetRuntime = targetRuntime;
+  }
+  return metadata;
+}
+var agentProjectMetadataReader = (projectDir, projectType) => projectType === "Agent" ? readAgentProjectMetadata(projectDir) : Promise.resolve({});
+
+// src/tool.ts
+var metadata = {
+  name: "flow-tool",
+  version: package_default.version,
+  description: "Create, debug, and run UiPath Flow projects and jobs.",
+  commandPrefix: "flow"
+};
+var registerCommands = async (program) => {
+  setAgentProjectMetadataReader(agentProjectMetadataReader);
+  if (isPreviewBuild()) {
+    const { registerFlowAuthoringCommands } = await import("./authoring-wpa6d0vf.js");
+    registerFlowAuthoringCommands(program);
+  }
+  registerInitCommand(program);
+  registerPackCommand(program);
+  registerPublishCommand(program);
+  registerValidateCommand(program);
+  registerDebugCommand(program);
+  registerDebugInstancesCommand(program);
+  registerEvalCommand(program);
+  registerMigrateCommand(program);
+  registerNodeCommand(program);
+  registerEdgeCommand(program);
+  registerBindingCommand(program);
+  registerProcessCommand(program);
+  registerJobCommand(program);
+  registerRegistryCommand2(program);
+  registerInstancesCommand(program);
+  registerProcessesCommand(program);
+  registerHitlCommand(program);
+  registerIncidentsCommand(program);
+  registerTidyCommand(program);
+  registerVariableCommand(program);
+};
+
+export { metadata, registerCommands };
+
+//# debugId=FE9DC859F1DB521864756E2164756E21