@uipath/case-tool 1.204.0 → 1.205.0-preview.258

package/dist/{packager-tool-167qap9m.js → packager-tool-aagnvyba.js}

@@ -1,13 +1,22 @@
 import {
   resolveJsonInput
-} from "./packager-tool-jfysbxdt.js";
-import {
-  getAuthContext
-} from "./packager-tool-v99ygh9f.js";
+} from "./packager-tool-mzf4gmph.js";
 import {
   DEBUG_MODE_MAP,
-  SIMULATION_MODE_MAP
-} from "./packager-tool-64rg5ekd.js";
+  SIMULATION_MODE_MAP,
+  beginDebugSession,
+  createDebugInstance,
+  debugPimsGet,
+  debugPimsPatch,
+  debugPimsPost,
+  debugPimsPut,
+  fetchDebugInstanceVariables,
+  getPersonalFolderKey
+} from "./packager-tool-9e59z4d6.js";
+import {
+  getAuthContext,
+  getLoginStatusAsync
+} from "./packager-tool-yn33pw57.js";
 import {
   DEFAULT_PAGE_SIZE,
   EXIT_CODES,
@@ -23,30 +32,7 @@ import {
   parseLimit,
   parseOffset,
   processContext
-} from "./packager-tool-3q3d1hk8.js";
-
-// ../maestro-sdk/src/query-string.ts
-function buildQueryString(params) {
-  const entries = [];
-  for (const [key, value] of Object.entries(params)) {
-    if (value === undefined)
-      continue;
-    if (Array.isArray(value)) {
-      for (const item of value) {
-        entries.push([key, item]);
-      }
-      continue;
-    }
-    entries.push([key, String(value)]);
-  }
-  if (entries.length === 0)
-    return "";
-  return `?${new URLSearchParams(entries).toString()}`;
-}
-
-// ../maestro-sdk/src/shared-commands/debug-instances.ts
-var VALID_DEBUG_MODES = Object.keys(DEBUG_MODE_MAP);
-var VALID_SIMULATION_MODES = Object.keys(SIMULATION_MODE_MAP);
+} from "./packager-tool-83v804p7.js";
 
 // ../maestro-sdk/src/client.ts
 function parseBackendErrorBody(body) {
@@ -194,6 +180,820 @@ async function createPimsConfig() {
   };
 }
 
+// ../maestro-sdk/src/query-string.ts
+function buildQueryString(params) {
+  const entries = [];
+  for (const [key, value] of Object.entries(params)) {
+    if (value === undefined)
+      continue;
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        entries.push([key, item]);
+      }
+      continue;
+    }
+    entries.push([key, String(value)]);
+  }
+  if (entries.length === 0)
+    return "";
+  return `?${new URLSearchParams(entries).toString()}`;
+}
+
+// ../maestro-sdk/src/with-debug-pims-call.ts
+async function createDebugPimsConfig() {
+  const status = await getLoginStatusAsync({
+    ensureTokenValidityMinutes: 10
+  });
+  if (status.loginStatus !== "Logged in" || !status.baseUrl || !status.accessToken) {
+    throw new Error(status.hint ? `Not logged in. ${status.hint}` : "Not logged in. Run 'uip login' first.");
+  }
+  if (!status.organizationId) {
+    throw new Error("Organization ID not available. Ensure you are logged in with an organization context.");
+  }
+  if (!status.tenantId) {
+    throw new Error("Tenant ID not available. Ensure UIPATH_TENANT_ID is set.");
+  }
+  if (!status.tenantName) {
+    throw new Error("Tenant name not available. Ensure you are logged in with a tenant context.");
+  }
+  return {
+    baseUrl: status.baseUrl,
+    organizationId: status.organizationId,
+    tenantName: status.tenantName,
+    tenantId: status.tenantId,
+    authToken: status.accessToken
+  };
+}
+async function withDebugPimsCall(fn, errorMessage) {
+  const [configError, config] = await catchError(createDebugPimsConfig());
+  if (configError) {
+    logger.warn(`${errorMessage}: ${configError.message}`);
+    OutputFormatter.error({
+      Result: RESULTS.Failure,
+      Message: errorMessage,
+      Instructions: configError.message
+    });
+    processContext.exit(1);
+    return;
+  }
+  if (!config.folderKey) {
+    const [folderError, folder] = await catchError(getPersonalFolderKey(config));
+    if (folderError) {
+      logger.warn(`Could not resolve personal folder: ${folderError.message}`);
+    } else {
+      config.folderKey = folder.key;
+      config.organizationUnitId = folder.id;
+    }
+  }
+  const [error, result] = await catchError(fn(config));
+  if (error) {
+    const msg = await extractErrorMessage(error);
+    logger.warn(`${errorMessage}: ${msg}`);
+    OutputFormatter.error({
+      Result: RESULTS.Failure,
+      Message: errorMessage,
+      Instructions: msg
+    });
+    processContext.exit(1);
+    return;
+  }
+  return result;
+}
+
+// ../maestro-sdk/src/shared-commands/examples.ts
+var INSTANCE = "f4a1c2b3-0000-4000-8000-000000000001";
+var FOLDER = "b2c3d4e5-0000-4000-8000-000000000002";
+var PROCESS = "c3d4e5f6-0000-4000-8000-000000000003";
+var INCIDENT = "d4e5f6a7-0000-4000-8000-000000000004";
+var ELEMENT = "Task_Review";
+var SOLUTION = "e5f6a7b8-0000-4000-8000-000000000009";
+var PROJECT = "f6a7b8c9-0000-4000-8000-00000000000a";
+var operation = (verb, code, description, status) => (prefix) => ({
+  Description: description,
+  Command: `${prefix} instance ${verb} ${INSTANCE} --folder-key ${FOLDER}`,
+  Output: { Code: code, Data: { InstanceId: INSTANCE, Status: status } }
+});
+var EXAMPLES = {
+  "instance list": (prefix) => ({
+    Description: "List the faulted instances in a folder",
+    Command: `${prefix} instance list --folder-key ${FOLDER} --status Faulted --limit 2`,
+    Output: {
+      Code: "InstanceList",
+      Data: [
+        {
+          InstanceId: INSTANCE,
+          InstanceDisplayName: "Claim 1042",
+          ProcessKey: PROCESS,
+          PackageVersion: "1.0.3",
+          LatestRunStatus: "Faulted",
+          StartedTime: "2026-10-13T09:12:00Z"
+        }
+      ]
+    }
+  }),
+  "instance get": (prefix) => ({
+    Description: "Get one instance and its latest run",
+    Command: `${prefix} instance get ${INSTANCE} --folder-key ${FOLDER}`,
+    Output: {
+      Code: "InstanceGet",
+      Data: {
+        InstanceId: INSTANCE,
+        InstanceDisplayName: "Claim 1042",
+        ProcessKey: PROCESS,
+        PackageVersion: "1.0.3",
+        LatestRunStatus: "Running",
+        StartedTime: "2026-10-13T09:12:00Z",
+        CompletedTime: null
+      }
+    }
+  }),
+  "instance pause": operation("pause", "InstancePaused", "Pause a running instance", "Paused"),
+  "instance resume": operation("resume", "InstanceResumed", "Resume a paused instance", "Running"),
+  "instance cancel": operation("cancel", "InstanceCanceled", "Cancel an instance", "Canceling"),
+  "instance retry": operation("retry", "InstanceRetried", "Retry a faulted instance from where it failed", "Running"),
+  "instance variables": (prefix) => ({
+    Description: "Read an instance's variables",
+    Command: `${prefix} instance variables ${INSTANCE} --folder-key ${FOLDER}`,
+    Output: {
+      Code: "InstanceVariables",
+      Data: {
+        InstanceId: INSTANCE,
+        ParentElementId: null,
+        GlobalVariables: [
+          {
+            Id: "claimAmount",
+            Name: "claimAmount",
+            Type: "number",
+            Value: 1200,
+            ElementId: "root",
+            Source: "=vars.claimAmount"
+          }
+        ],
+        Elements: []
+      }
+    }
+  }),
+  "instance variables-all": (prefix) => ({
+    Description: "Read the variables of every scope in an instance",
+    Command: `${prefix} instance variables-all ${INSTANCE} --folder-key ${FOLDER}`,
+    Output: {
+      Code: "InstanceVariablesAll",
+      Data: {
+        Variables: [
+          {
+            InstanceId: INSTANCE,
+            ParentElementId: null,
+            GlobalVariables: [],
+            Elements: []
+          }
+        ]
+      }
+    }
+  }),
+  "instance global-variables": (prefix) => ({
+    Description: "Read an instance's global variables",
+    Command: `${prefix} instance global-variables ${INSTANCE} --folder-key ${FOLDER}`,
+    Output: {
+      Code: "InstanceGlobalVariables",
+      Data: {
+        InstanceId: INSTANCE,
+        Globals: { claimAmount: 1200 },
+        Count: 1,
+        RetrievedAt: "2026-10-13T09:20:00Z"
+      }
+    }
+  }),
+  "instance variables-set": (prefix) => ({
+    Description: "Patch variables on a running instance from a file",
+    Command: `${prefix} instance variables-set ${INSTANCE} --folder-key ${FOLDER} --inputs @patch.json`,
+    Output: {
+      Code: "InstanceVariablesSet",
+      Data: {}
+    }
+  }),
+  "instance incidents": (prefix) => ({
+    Description: "List the incidents an instance raised",
+    Command: `${prefix} instance incidents ${INSTANCE} --folder-key ${FOLDER}`,
+    Output: {
+      Code: "InstanceIncidents",
+      Data: [
+        {
+          IncidentId: INCIDENT,
+          InstanceId: INSTANCE,
+          ElementId: ELEMENT,
+          IncidentStatus: "Open",
+          ErrorCode: "TaskFailed",
+          ErrorMessage: "The action app returned an error"
+        }
+      ]
+    }
+  }),
+  "instance asset": (prefix) => ({
+    Description: "Get the asset an instance runs",
+    Command: `${prefix} instance asset ${INSTANCE} --folder-key ${FOLDER}`,
+    Output: { Code: "InstanceAsset", Data: {} }
+  }),
+  "instance migrate": (prefix) => ({
+    Description: "Move an instance to a newer package version",
+    Command: `${prefix} instance migrate ${INSTANCE} 1.0.4 --folder-key ${FOLDER} --comment "Fix review step"`,
+    Output: {
+      Code: "InstanceMigrated",
+      Data: { InstanceId: INSTANCE, Status: "Running" }
+    }
+  }),
+  "instance goto": (prefix) => ({
+    Description: "Move an instance's cursor from one element to another",
+    Command: `${prefix} instance goto ${INSTANCE} '[{"sourceElementId":"${ELEMENT}","targetElementId":"Task_Approve"}]' --folder-key ${FOLDER}`,
+    Output: {
+      Code: "InstanceGoto",
+      Data: { InstanceId: INSTANCE, Status: "Running" }
+    }
+  }),
+  "instance cursors": (prefix) => ({
+    Description: "List the elements an instance is currently at",
+    Command: `${prefix} instance cursors ${INSTANCE} --folder-key ${FOLDER}`,
+    Output: {
+      Code: "InstanceCursors",
+      Data: { ElementIds: [ELEMENT] }
+    }
+  }),
+  "instance message send": (prefix) => ({
+    Description: "Send a message to the instances waiting for it",
+    Command: `${prefix} instance message send --folder-key ${FOLDER} --inputs @message.json`,
+    Output: {
+      Code: "MessageSent",
+      Data: {
+        Id: "e5f6a7b8-0000-4000-8000-000000000005",
+        JobId: "f6a7b8c9-0000-4000-8000-000000000006"
+      }
+    }
+  }),
+  "instance element-executions": (prefix) => ({
+    Description: "List how each element of an instance ran",
+    Command: `${prefix} instance element-executions ${INSTANCE} --folder-key ${FOLDER}`,
+    Output: {
+      Code: "InstanceElementExecutions",
+      Data: {
+        InstanceId: INSTANCE,
+        ProcessKey: PROCESS,
+        Status: "Running",
+        ElementExecutions: [
+          {
+            ElementId: ELEMENT,
+            ElementType: "UserTask",
+            Status: "Completed",
+            StartedTimeUtc: "2026-10-13T09:12:05Z"
+          }
+        ]
+      }
+    }
+  }),
+  "instance element cancel": (prefix) => ({
+    Description: "Cancel one running element of an instance",
+    Command: `${prefix} instance element cancel ${INSTANCE} ${ELEMENT} --folder-key ${FOLDER}`,
+    Output: {
+      Code: "ElementCanceled",
+      Data: { InstanceId: INSTANCE, Status: "Running" }
+    }
+  }),
+  "instance element retry": (prefix) => ({
+    Description: "Retry one faulted element of an instance",
+    Command: `${prefix} instance element retry ${INSTANCE} ${ELEMENT} --folder-key ${FOLDER}`,
+    Output: {
+      Code: "ElementRetried",
+      Data: { InstanceId: INSTANCE, Status: "Running" }
+    }
+  }),
+  "incident summary": (prefix) => ({
+    Description: "Summarize the open incidents in a folder by error",
+    Command: `${prefix} incident summary --folder-key ${FOLDER} --limit 2`,
+    Output: {
+      Code: "IncidentSummary",
+      Data: [
+        {
+          ProcessKey: PROCESS,
+          ErrorCode: "TaskFailed",
+          ErrorMessage: "The action app returned an error",
+          Count: 3,
+          FirstTimeUtc: "2026-10-12T15:02:00Z"
+        }
+      ]
+    }
+  }),
+  "incident get": (prefix) => ({
+    Description: "Get one incident with its error details",
+    Command: `${prefix} incident get ${INCIDENT} --folder-key ${FOLDER}`,
+    Output: {
+      Code: "IncidentGet",
+      Data: {
+        IncidentId: INCIDENT,
+        InstanceId: INSTANCE,
+        ProcessKey: PROCESS,
+        IncidentStatus: "Open",
+        ElementId: ELEMENT,
+        ErrorCode: "TaskFailed",
+        ErrorMessage: "The action app returned an error",
+        ErrorTime: "2026-10-12T15:02:00Z"
+      }
+    }
+  }),
+  "process settings get": (prefix) => ({
+    Description: "Read a process's settings",
+    Command: `${prefix} process settings get ${PROCESS} --folder-key ${FOLDER}`,
+    Output: {
+      Code: "ProcessSettingsGet",
+      Data: {
+        VariableTags: {
+          Elements: {},
+          SourcePackageVersion: "1.0.3",
+          LastUpdateTimeUtc: "2026-10-12T15:00:00Z"
+        }
+      }
+    }
+  }),
+  "process settings set": (prefix) => ({
+    Description: "Replace a process's settings from a file",
+    Command: `${prefix} process settings set ${PROCESS} --folder-key ${FOLDER} --inputs @settings.json`,
+    Output: {
+      Code: "ProcessSettingsSet",
+      Data: {}
+    }
+  }),
+  "process variable-tags get": (prefix) => ({
+    Description: "Read which variables are tagged for instance search",
+    Command: `${prefix} process variable-tags get ${PROCESS} --folder-key ${FOLDER}`,
+    Output: {
+      Code: "ProcessVariableTagsGet",
+      Data: {
+        Elements: {},
+        SourcePackageVersion: "1.0.3",
+        LastUpdateTimeUtc: "2026-10-12T15:00:00Z"
+      }
+    }
+  }),
+  "process variable-tags set": (prefix) => ({
+    Description: "Make a variable searchable when filtering instances",
+    Command: `${prefix} process variable-tags set ${PROCESS} --folder-key ${FOLDER} --variable claimAmount --searchable true`,
+    Output: {
+      Code: "ProcessVariableTagsSet",
+      Data: {
+        Updated: [
+          {
+            ElementId: ELEMENT,
+            Name: "claimAmount",
+            Tags: ["Searchable"]
+          }
+        ],
+        VariableTags: {
+          Elements: {
+            [ELEMENT]: {
+              Outputs: [
+                {
+                  Name: "claimAmount",
+                  Tags: ["Searchable"],
+                  ExtractPath: "claimAmount",
+                  Label: "Claim amount",
+                  ExtractedValueType: "number"
+                }
+              ]
+            }
+          },
+          SourcePackageVersion: "1.0.3",
+          LastUpdateTimeUtc: "2026-10-12T15:00:00Z"
+        }
+      }
+    }
+  }),
+  "processes list": (prefix) => ({
+    Description: "List processes with their running and faulted counts",
+    Command: `${prefix} processes list --folder-key ${FOLDER} --limit 2`,
+    Output: {
+      Code: "ProcessList",
+      Data: {
+        Processes: [
+          { ProcessKey: PROCESS, RunningCount: 4, FaultedCount: 1 }
+        ]
+      }
+    }
+  }),
+  "processes incidents": (prefix) => ({
+    Description: "List a process's incidents",
+    Command: `${prefix} processes incidents ${PROCESS} --folder-key ${FOLDER}`,
+    Output: {
+      Code: "ProcessIncidents",
+      Data: [
+        {
+          IncidentId: INCIDENT,
+          InstanceId: INSTANCE,
+          ProcessKey: PROCESS,
+          ElementId: ELEMENT,
+          IncidentStatus: "Open",
+          ErrorCode: "TaskFailed",
+          ErrorMessage: "The action app returned an error"
+        }
+      ]
+    }
+  }),
+  "processes diagnose": (prefix) => ({
+    Description: "Diagnose why a process's instances fault",
+    Command: `${prefix} processes diagnose ${PROCESS} --folder-key ${FOLDER}`,
+    Output: {
+      Code: "ProcessDiagnostics",
+      Data: {
+        ProcessKey: PROCESS,
+        FolderKey: FOLDER,
+        Summary: {
+          ProcessKey: PROCESS,
+          RunningCount: 4,
+          FaultedCount: 1
+        },
+        FaultedCount: 1,
+        RunningCount: 4,
+        Incidents: [
+          {
+            IncidentId: INCIDENT,
+            InstanceId: INSTANCE,
+            ElementId: ELEMENT,
+            ErrorCode: "TaskFailed"
+          }
+        ],
+        IncidentCount: 1,
+        ErrorCodes: [
+          {
+            ErrorCode: "TaskFailed",
+            ErrorMessage: "The action app returned an error"
+          }
+        ],
+        ErrorCodeCount: 1
+      }
+    }
+  }),
+  "processes error-codes": (prefix) => ({
+    Description: "List the error codes a process's incidents carry",
+    Command: `${prefix} processes error-codes ${PROCESS} --folder-key ${FOLDER}`,
+    Output: {
+      Code: "ProcessIncidentErrorCodes",
+      Data: [
+        {
+          ErrorCode: "TaskFailed",
+          ErrorMessage: "The action app returned an error"
+        }
+      ]
+    }
+  }),
+  "debug-instance create": (prefix) => ({
+    Description: "Start a debug run of an uploaded solution's entry point",
+    Command: `${prefix} debug-instance create --solution-id ${SOLUTION} --project-id ${PROJECT} --entry-point "/Main.bpmn#start" --debug-mode StepByStep`,
+    Output: {
+      Code: "DebugInstanceCreated",
+      Data: {
+        InstanceId: INSTANCE,
+        RunId: "a7b8c9d0-0000-4000-8000-000000000007",
+        JobKey: "b8c9d0e1-0000-4000-8000-000000000008"
+      }
+    }
+  }),
+  "debug-instance status": (prefix) => ({
+    Description: "Check where a debug run is",
+    Command: `${prefix} debug-instance status ${INSTANCE}`,
+    Output: {
+      Code: "DebugInstanceStatus",
+      Data: {
+        InstanceId: INSTANCE,
+        Status: "Paused",
+        StartedTimeUtc: "2026-10-13T09:12:00Z",
+        CompletedTimeUtc: null
+      }
+    }
+  }),
+  "debug-instance breakpoints": (prefix) => ({
+    Description: "Replace a debug run's breakpoints from a file",
+    Command: `${prefix} debug-instance breakpoints ${INSTANCE} --inputs @breakpoints.json`,
+    Output: {
+      Code: "DebugInstanceBreakpointsUpdated",
+      Data: {}
+    }
+  }),
+  "debug-instance cancel": (prefix) => ({
+    Description: "Stop a debug run",
+    Command: `${prefix} debug-instance cancel ${INSTANCE}`,
+    Output: {
+      Code: "DebugInstanceCanceled",
+      Data: {}
+    }
+  }),
+  "debug-instance continue": (prefix) => ({
+    Description: "Continue a paused debug run",
+    Command: `${prefix} debug-instance continue ${INSTANCE}`,
+    Output: {
+      Code: "DebugInstanceContinued",
+      Data: {}
+    }
+  }),
+  "debug-instance incidents": (prefix) => ({
+    Description: "List the incidents a debug run raised",
+    Command: `${prefix} debug-instance incidents ${INSTANCE}`,
+    Output: {
+      Code: "DebugInstanceIncidents",
+      Data: [
+        {
+          IncidentId: INCIDENT,
+          ElementId: ELEMENT,
+          ErrorCode: "TaskFailed"
+        }
+      ]
+    }
+  }),
+  "debug-instance variables": (prefix) => ({
+    Description: "Read a paused debug run's variables",
+    Command: `${prefix} debug-instance variables ${INSTANCE}`,
+    Output: {
+      Code: "DebugInstanceVariables",
+      Data: { InstanceId: INSTANCE, Globals: {}, Elements: [] }
+    }
+  }),
+  "debug-instance variables-set": (prefix) => ({
+    Description: "Patch a paused debug run's variables from a file",
+    Command: `${prefix} debug-instance variables-set ${INSTANCE} --inputs @patch.json`,
+    Output: {
+      Code: "DebugInstanceVariablesSet",
+      Data: {}
+    }
+  }),
+  "debug-instance variables-all": (prefix) => ({
+    Description: "Read the variables of every scope in a debug run",
+    Command: `${prefix} debug-instance variables-all ${INSTANCE}`,
+    Output: {
+      Code: "DebugInstanceVariablesAll",
+      Data: { Variables: [] }
+    }
+  })
+};
+var pathOf = (command) => {
+  const names = [];
+  for (let at = command;at !== null; at = at.parent) {
+    if (at.parent === null)
+      break;
+    names.unshift(at.name());
+  }
+  return ["uip", ...names];
+};
+var attachSharedExamples = (group) => {
+  const visit = (command) => {
+    if (command.commands.length > 0) {
+      for (const child of command.commands)
+        visit(child);
+      return;
+    }
+    const path = pathOf(command);
+    for (let words = 3;words >= 2; words -= 1) {
+      const key = path.slice(-words).join(" ");
+      const example = EXAMPLES[key];
+      if (example === undefined)
+        continue;
+      const prefix = path.slice(0, path.length - words).join(" ");
+      command.examples([example(prefix)]);
+      return;
+    }
+  };
+  visit(group);
+};
+
+// ../maestro-sdk/src/shared-commands/debug-instances.ts
+var DEBUG_API_PREFIX = "/api/v1/debug-instances";
+var VALID_DEBUG_MODES = Object.keys(DEBUG_MODE_MAP);
+var VALID_SIMULATION_MODES = Object.keys(SIMULATION_MODE_MAP);
+var registerSharedDebugInstanceCommands = (program, config) => {
+  const { toolLabel } = config;
+  const debugInstance = program.command("debug-instance").description(`Manage ${toolLabel} debug instance operations`);
+  debugInstance.command("create").description(`Create a ${toolLabel} debug instance from an already-uploaded solution`).requiredOption("--solution-id <id>", "Solution ID (from a previous upload or Studio Web)").requiredOption("--project-id <id>", "Studio Web project ID within the solution").requiredOption("--entry-point <path>", 'Entry point path (e.g. "/Main.bpmn#start")').option("--process-type <type>", "Process type", "processOrchestration").option("--debug-mode <mode>", "Debug mode: Default (pause at breakpoints), StepByStep (pause at every step), SingleStep (one step only)", "Default").option("--simulation-mode <mode>", "Simulation mode: None, All (simulate all elements), Selective (simulate except opt-outs)", "None").option("-i, --inputs <json>", "Input arguments as JSON string", "{}").trackedAction(processContext, async (options) => {
+    if (!VALID_DEBUG_MODES.includes(options.debugMode)) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: `Invalid --debug-mode "${options.debugMode}". Valid values: ${VALID_DEBUG_MODES.join(", ")}.`,
+        Instructions: ""
+      });
+      processContext.exit(1);
+      return;
+    }
+    if (!VALID_SIMULATION_MODES.includes(options.simulationMode)) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: `Invalid --simulation-mode "${options.simulationMode}". Valid values: ${VALID_SIMULATION_MODES.join(", ")}.`,
+        Instructions: ""
+      });
+      processContext.exit(1);
+      return;
+    }
+    const [configError, config2] = await catchError(createDebugPimsConfig());
+    if (configError) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Error creating debug instance",
+        Instructions: configError.message
+      });
+      processContext.exit(1);
+      return;
+    }
+    const [folderError, folder] = await catchError(getPersonalFolderKey(config2));
+    if (folderError) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Error getting personal workspace folder",
+        Instructions: folderError.message
+      });
+      processContext.exit(1);
+      return;
+    }
+    config2.folderKey = folder.key;
+    config2.organizationUnitId = folder.id;
+    const [sessionError, session] = await catchError(beginDebugSession(config2, options.inputs));
+    if (sessionError) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Error beginning debug session",
+        Instructions: sessionError.message
+      });
+      processContext.exit(1);
+      return;
+    }
+    const [createError, result] = await catchError(createDebugInstance(config2, session.jobKey, options.solutionId, options.projectId, options.entryPoint, options.processType, options.debugMode, options.simulationMode));
+    if (createError) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Error creating debug instance",
+        Instructions: createError.message
+      });
+      processContext.exit(1);
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "DebugInstanceCreated",
+      Data: {
+        instanceId: result.instanceId,
+        runId: result.runId,
+        jobKey: session.jobKey
+      },
+      Instructions: "Use 'debug-instance status <instance-id>' to check the run. Use 'debug-instance incidents <instance-id>' or 'debug-instance variables <instance-id>' to inspect it."
+    });
+  });
+  debugInstance.command("status").description(`Get the current status of a ${toolLabel} debug instance`).argument("<instance-id>", "Debug instance ID").trackedAction(processContext, async (instanceId) => {
+    const result = await withDebugPimsCall((cfg) => debugPimsGet(cfg, `${DEBUG_API_PREFIX}/${instanceId}/element-executions`, "get-debug-instance-status"), "Error getting debug instance status");
+    if (!result)
+      return;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "DebugInstanceStatus",
+      Data: result
+    });
+  });
+  debugInstance.command("breakpoints").description(`Update breakpoints for a ${toolLabel} debug instance`).argument("<instance-id>", "Debug instance ID").option("--inputs <value>", "Breakpoints payload as JSON string, @file path, or piped via stdin").trackedAction(processContext, async (instanceId, options) => {
+    const [readError, data] = await catchError(resolveJsonInput({
+      inline: options.inputs,
+      allowStdin: true
+    }));
+    if (readError) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Error reading breakpoints input",
+        Instructions: readError.message
+      });
+      processContext.exit(1);
+      return;
+    }
+    const body = data ?? {
+      breakpoints: []
+    };
+    const result = await withDebugPimsCall((cfg) => debugPimsPut(cfg, `${DEBUG_API_PREFIX}/${instanceId}/breakpoints`, body), "Error updating breakpoints");
+    if (!result)
+      return;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "DebugInstanceBreakpointsUpdated",
+      Data: result
+    });
+  });
+  debugInstance.command("cancel").description(`Cancel a ${toolLabel} debug instance`).argument("<instance-id>", "Debug instance ID").trackedAction(processContext, async (instanceId) => {
+    const result = await withDebugPimsCall((cfg) => debugPimsPost(cfg, `${DEBUG_API_PREFIX}/${instanceId}/cancel`, { comment: "" }), "Error canceling debug instance");
+    if (!result)
+      return;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "DebugInstanceCanceled",
+      Data: result
+    });
+  });
+  debugInstance.command("continue").description(`Continue execution on a paused ${toolLabel} debug instance`).argument("<instance-id>", "Debug instance ID").option("--inputs <value>", "Continue payload as JSON string, @file path, or piped via stdin").trackedAction(processContext, async (instanceId, options) => {
+    const [readError, data] = await catchError(resolveJsonInput({
+      inline: options.inputs,
+      allowStdin: true
+    }));
+    if (readError) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Error reading continue input",
+        Instructions: readError.message
+      });
+      processContext.exit(1);
+      return;
+    }
+    const body = data ?? {
+      nextStep: false
+    };
+    const result = await withDebugPimsCall((cfg) => debugPimsPost(cfg, `${DEBUG_API_PREFIX}/${instanceId}/continue`, body), "Error continuing debug instance");
+    if (!result)
+      return;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "DebugInstanceContinued",
+      Data: result
+    });
+  });
+  debugInstance.command("incidents").description(`Get incidents for a ${toolLabel} debug instance`).argument("<instance-id>", "Debug instance ID").trackedAction(processContext, async (instanceId) => {
+    const result = await withDebugPimsCall((cfg) => debugPimsGet(cfg, `${DEBUG_API_PREFIX}/${instanceId}/incidents`), "Error getting debug instance incidents");
+    if (!result)
+      return;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "DebugInstanceIncidents",
+      Data: result ?? []
+    });
+  });
+  debugInstance.command("variables").description(`Get variables for a ${toolLabel} debug instance`).argument("<instance-id>", "Debug instance ID").option("--parent-element-id <id>", "Filter variables by parent element ID").option("--expected-outputs <ids...>", "Output variable ids the record must define; retried until it does, failed if it never does").trackedAction(processContext, async (instanceId, options) => {
+    const expectGlobals = options.expectedOutputs ?? [];
+    if (expectGlobals.length > 0 && options.parentElementId !== undefined) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "--expected-outputs cannot be combined with --parent-element-id",
+        Instructions: "Drop --parent-element-id: --expected-outputs checks the instance's root variables record."
+      });
+      processContext.exit(1);
+      return;
+    }
+    const query = buildQueryString({
+      parentElementId: options.parentElementId
+    });
+    const result = await withDebugPimsCall((cfg) => expectGlobals.length > 0 ? fetchDebugInstanceVariables(cfg, instanceId, {
+      expectGlobals
+    }) : debugPimsGet(cfg, `${DEBUG_API_PREFIX}/${instanceId}/variables${query}`), "Error getting debug instance variables");
+    if (!result)
+      return;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "DebugInstanceVariables",
+      Data: result
+    });
+  });
+  debugInstance.command("variables-set").description(`Update variables for a ${toolLabel} debug instance`).argument("<instance-id>", "Debug instance ID").option("--inputs <value>", "Patch variables payload as JSON string, @file path, or piped via stdin").option("--parent-element-id <id>", "Filter by parent element ID").trackedAction(processContext, async (instanceId, options) => {
+    const [readError, data] = await catchError(resolveJsonInput({
+      inline: options.inputs,
+      allowStdin: true
+    }));
+    if (readError) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Error reading variables payload",
+        Instructions: readError.message
+      });
+      processContext.exit(1);
+      return;
+    }
+    if (data === undefined) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Missing variables payload",
+        Instructions: "Provide --inputs <json|@file> or pipe JSON via stdin."
+      });
+      processContext.exit(1);
+      return;
+    }
+    const body = data;
+    const query = buildQueryString({
+      parentElementId: options.parentElementId
+    });
+    const result = await withDebugPimsCall((cfg) => debugPimsPatch(cfg, `${DEBUG_API_PREFIX}/${instanceId}/variables${query}`, body), "Error updating debug instance variables");
+    if (!result)
+      return;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "DebugInstanceVariablesSet",
+      Data: result
+    });
+  });
+  debugInstance.command("variables-all").description(`Get all variables including subprocesses for a ${toolLabel} debug instance`).argument("<instance-id>", "Debug instance ID").trackedAction(processContext, async (instanceId) => {
+    const result = await withDebugPimsCall((cfg) => debugPimsGet(cfg, `${DEBUG_API_PREFIX}/${instanceId}/variables-all`), "Error getting all debug instance variables");
+    if (!result)
+      return;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "DebugInstanceVariablesAll",
+      Data: result
+    });
+  });
+  attachSharedExamples(debugInstance);
+};
+
 // ../maestro-sdk/src/with-pims-call.ts
 var NETWORK_ERROR_CODES = new Set([
   "ECONNREFUSED",
@@ -386,6 +1186,7 @@ var registerSharedIncidentCommands = (program, config) => {
       Data: result
     });
   });
+  attachSharedExamples(incident);
 };
 
 // ../maestro-sdk/src/instance-status.ts
@@ -798,6 +1599,7 @@ var registerSharedInstanceCommands = (program, config) => {
       Data: result
     });
   });
+  attachSharedExamples(instances);
 };
 
 // ../maestro-sdk/src/shared-commands/process.ts
@@ -1040,14 +1842,19 @@ var registerSharedProcessCommands = (processCmd, config) => {
     }
     await setVariableTagsFromPayload(processKey, options);
   });
+  attachSharedExamples(settingsCmd);
+  attachSharedExamples(variableTagsCmd);
 };
 
 // ../maestro-sdk/src/shared-commands/processes.ts
-function findProcessSummary(summaries, processKey) {
+async function findProcessSummary(config, processKey, folderKey, processType) {
+  const page = await pimsGet(config, `/processes/summary${buildQueryString({ processType, processKey })}`, { folderKey });
+  const summaries = Array.isArray(page?.processes) ? page.processes : [];
   return summaries.find((summary) => summary.processKey === processKey) ?? null;
 }
 var registerSharedProcessesCommands = (program, config) => {
   const { toolLabel, processType } = config;
+  const incidentsQuery = buildQueryString({ processType });
   const processes = program.command("processes").description(`Manage ${toolLabel} process summaries`);
   processes.command("list").description(`List all ${toolLabel} process summaries`).option("--folder-key <key>", "Folder key").option("-l, --limit <number>", "Number of items to return (1-10000)", parseLimit).option("--offset <number>", "Number of items to skip (0-1000000)", parseOffset, 0).option("--status <status>", "Filter by process status").trackedAction(processContext, async (options) => {
     const query = buildQueryString({
@@ -1068,7 +1875,7 @@ var registerSharedProcessesCommands = (program, config) => {
   });
   processes.command("incidents").description(`Get incidents for a specific ${toolLabel} process`).argument("<process-key>", "Process definition key").requiredOption("--folder-key <key>", "Folder key").trackedAction(processContext, async (processKey, options) => {
     const reqOptions = { folderKey: options.folderKey };
-    const result = await withPimsCall((config2) => pimsGet(config2, `/incidents/process/${encodeURIComponent(processKey)}`, reqOptions), "Error getting process incidents", { resource: "process", id: processKey });
+    const result = await withPimsCall((config2) => pimsGet(config2, `/incidents/process/${encodeURIComponent(processKey)}${incidentsQuery}`, reqOptions), "Error getting process incidents", { resource: "process", id: processKey });
     if (!result)
       return;
     OutputFormatter.success({
@@ -1079,12 +1886,11 @@ var registerSharedProcessesCommands = (program, config) => {
   });
   processes.command("diagnose").description(`Correlate ${toolLabel} process summary, incidents, and error codes`).argument("<process-key>", "Process definition key").requiredOption("--folder-key <key>", "Folder key").trackedAction(processContext, async (processKey, options) => {
     const result = await withPimsCall(async (config2) => {
-      const query = processType ? buildQueryString({ processType }) : "";
-      const summaries = await pimsGet(config2, `/processes/summary${query}`);
-      const incidents = await pimsGet(config2, `/incidents/process/${encodeURIComponent(processKey)}`, { folderKey: options.folderKey });
+      const summary = await findProcessSummary(config2, processKey, options.folderKey, processType);
+      const incidents = await pimsGet(config2, `/incidents/process/${encodeURIComponent(processKey)}${incidentsQuery}`, { folderKey: options.folderKey });
       const errorCodes = await pimsGet(config2, `/incidents/process/${encodeURIComponent(processKey)}/error-codes`, { folderKey: options.folderKey });
       return {
-        summary: findProcessSummary(summaries, processKey),
+        summary,
         incidents,
         errorCodes: errorCodes.errorCodes || []
       };
@@ -1118,8 +1924,9 @@ var registerSharedProcessesCommands = (program, config) => {
       Data: result.errorCodes || []
     });
   });
+  attachSharedExamples(processes);
 };
 
-export { registerSharedIncidentCommands, registerSharedInstanceCommands, registerSharedProcessCommands, registerSharedProcessesCommands };
+export { pimsGet, pimsPost, pimsPut, pimsPatch, createPimsConfig, buildQueryString, withDebugPimsCall, registerSharedDebugInstanceCommands, withPimsCall, registerSharedIncidentCommands, registerSharedInstanceCommands, registerSharedProcessCommands, registerSharedProcessesCommands };
 
-//# debugId=98A588F258A04C4164756E2164756E21
+//# debugId=5B0AC5D48415912064756E2164756E21