@getmagical/cli 0.2.2 → 0.2.4

package/dist/index.js

@@ -7088,6 +7088,56 @@ var import_ts_essentials = __toESM(require_dist(), 1);
 // ../common/dist/src/stdlib/result.util.js
 import { z } from "zod";
 
+// ../common/dist/src/stdlib/error-temporal.js
+function isErrorLike(obj) {
+  return typeof obj === "object" && obj !== null && "name" in obj && "message" in obj && typeof obj.name === "string" && typeof obj.message === "string";
+}
+function isTemporalApplicationFailure(error) {
+  if (!isErrorLike(error)) {
+    return false;
+  }
+  return error.name === "ApplicationFailure" || !!error.stack?.startsWith("ApplicationFailure");
+}
+function isTemporalActivityFailure(error) {
+  if (!isErrorLike(error)) {
+    return false;
+  }
+  return error.name === "ActivityFailure" || error.message === "Activity task failed";
+}
+function isTemporalChildWorkflowFailure(error) {
+  if (!isErrorLike(error)) {
+    return false;
+  }
+  return error.name === "ChildWorkflowFailure" || error.message === "Child Workflow execution failed";
+}
+function isTemporalFailure(error) {
+  if (!isErrorLike(error)) {
+    return false;
+  }
+  return isTemporalApplicationFailure(error) || isTemporalActivityFailure(error) || isTemporalChildWorkflowFailure(error);
+}
+
+// ../common/dist/src/stdlib/error-serialization.js
+function getErrorMessage2(error, maxDepth = 10) {
+  if (error instanceof Error || isErrorLike2(error)) {
+    if (error.cause && maxDepth > 0) {
+      if (isTemporalFailure(error)) {
+        return getErrorMessage2(error.cause, maxDepth - 1);
+      }
+      return `${error.message}
+${getErrorMessage2(error.cause, maxDepth - 1)}`;
+    }
+    return error.message;
+  }
+  if (typeof error === "string" || typeof error === "number" || typeof error === "boolean" || error === void 0) {
+    return String(error);
+  }
+  return JSON.stringify(error);
+}
+function isErrorLike2(obj) {
+  return typeof obj === "object" && obj !== null && "name" in obj && "message" in obj && typeof obj.name === "string" && typeof obj.message === "string";
+}
+
 // ../common/dist/src/stdlib/error-user-facing.js
 var USER_FACING_STATUS_MESSAGES = /* @__PURE__ */ new Map([
   [400, "Bad Request"],
@@ -7245,9 +7295,12 @@ function resolveApiDetails({ appError, statusCode }) {
   if (!shouldExposeMessage({ appError, statusCode })) {
     return void 0;
   }
+  const rawDetails = toUserFacingDetailsValue(appError.details, 4);
+  const serializedDetails = rawDetails && typeof rawDetails === "object" && !Array.isArray(rawDetails) && Object.keys(rawDetails).length > 0 ? rawDetails : void 0;
   const zodIssues = getZodIssuesFromCause(appError.cause);
   if (zodIssues && zodIssues.length > 0) {
     return {
+      ...serializedDetails,
       validationErrors: zodIssues.map((issue) => ({
         path: Array.isArray(issue.path) ? issue.path.map(String).join(".") : "",
         message: typeof issue.message === "string" ? issue.message : "Invalid value",
@@ -7255,11 +7308,7 @@ function resolveApiDetails({ appError, statusCode }) {
       }))
     };
   }
-  const rawDetails = toUserFacingDetailsValue(appError.details, 4);
-  if (rawDetails && typeof rawDetails === "object" && !Array.isArray(rawDetails) && Object.keys(rawDetails).length > 0) {
-    return rawDetails;
-  }
-  return void 0;
+  return serializedDetails;
 }
 function getGraphQLErrorCodeFromAppErrorCode(code) {
   if (code === 400) {
@@ -12207,6 +12256,16 @@ function replaceHandlebarsTemplates(value) {
   return value.replaceAll(HANDLEBARS_TEMPLATE_GLOBAL_REGEX, URL_TEMPLATE_PLACEHOLDER_VALUE);
 }
 
+// ../common/dist/src/stdlib/unsafe-object-key.util.js
+var UNSAFE_OBJECT_KEYS = /* @__PURE__ */ new Set([
+  "__proto__",
+  "constructor",
+  "prototype"
+]);
+function isUnsafeObjectKey(value) {
+  return UNSAFE_OBJECT_KEYS.has(value);
+}
+
 // ../common/dist/src/models/websocket/actions/scroll.js
 import { z as z9 } from "zod";
 var scrollDataSchema = z9.object({
@@ -12663,15 +12722,15 @@ var baseToolDeclarations = {
   },
   updateStoreValues: {
     id: "updateStoreValues",
-    description: "Update values in the automation store. Set scalar leaf paths, append one item or a list of items to array paths, replace complete arrays, and clear scalar or array paths in a single mutation.",
+    description: "Update values in the automation store. Set complete scalar or Object values, append one item or a list of items to array paths, replace complete arrays, and clear supported scalar, Object, or array paths in a single mutation.",
     parameters: z12.object({
       [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS,
       updates: z12.array(z12.object({
-        path: z12.string().min(1).describe("Scalar leaf path to set or array path to append to or replace, such as patient.name or documents."),
-        arrayMode: z12.enum(["append", "appendList", "replace"]).optional().describe("Array mutation behavior. Omit or use append to add one item, use appendList to add every item in the supplied list, or use replace to set the complete array. Do not use this for scalar paths."),
-        value: z12.json().describe("Concrete JSON value for this update. Scalar paths receive this value. Array append updates receive one item, appendList updates receive a list of items, and replacements receive the complete list.")
+        path: z12.string().min(1).describe("Scalar or Object path to set, or array path to append to or replace, such as patient.name, patient, or documents. The root Store path is not supported."),
+        arrayMode: z12.enum(["append", "appendList", "replace"]).optional().describe("Array mutation behavior. Omit or use append to add one item, use appendList to add every item in the supplied list, or use replace to set the complete array. Do not use this for scalar or Object paths."),
+        value: z12.json().describe("Concrete JSON value for this update. Scalar and Object paths receive the complete value. Array append updates receive one item, appendList updates receive a list of items, and replacements receive the complete list.")
       })).optional().describe("Store values to update. Omit or pass an empty array when only clearing values."),
-      clears: z12.array(z12.string().min(1)).optional().describe("Scalar leaf or array store paths to clear. Clearing an array writes an empty list. Omit or pass an empty array when only updating values.")
+      clears: z12.array(z12.string().min(1)).optional().describe("Optional scalar or Object paths, or array Store paths, to clear. Clearing an array writes an empty list. Omit or pass an empty array when only updating values.")
     }).superRefine((value, context) => {
       const updates = value.updates ?? [];
       const clears = value.clears ?? [];
@@ -13374,25 +13433,12 @@ function getIsKnowledgeBaseAssetPathAllowed(path7) {
   return isTopLevelAssetPath || isAutomationAssetPath || isAutomationAgentAssetPath;
 }
 
-// ../common/dist/src/utils/automation-variable-path.util.js
-var AUTOMATION_VARIABLE_PATH_SEGMENT_PATTERN = String.raw`[A-Za-z_][A-Za-z0-9_-]*`;
-var AUTOMATION_VARIABLE_PATH_PATTERN = String.raw`${AUTOMATION_VARIABLE_PATH_SEGMENT_PATTERN}(?:\.${AUTOMATION_VARIABLE_PATH_SEGMENT_PATTERN})*`;
-var DANGEROUS_AUTOMATION_VARIABLE_OBJECT_KEYS = /* @__PURE__ */ new Set([
-  "__proto__",
-  "constructor",
-  "prototype"
-]);
-var AUTOMATION_VARIABLE_PATH_SEGMENT_REGEX = new RegExp(`^${AUTOMATION_VARIABLE_PATH_SEGMENT_PATTERN}$`, "u");
-function isDangerousAutomationVariableObjectKey(value) {
-  return DANGEROUS_AUTOMATION_VARIABLE_OBJECT_KEYS.has(value);
-}
-
 // ../common/dist/src/utils/ponr-key-field-path.util.js
 var POINT_OF_NO_RETURN_KEY_FIELD_ROOTS = /* @__PURE__ */ new Set(["input", "store"]);
 function parsePointOfNoReturnKeyFieldPath(keyField) {
   const segments = keyField.split(".");
   const [root, ...pathSegments] = segments;
-  if (root === void 0 || !POINT_OF_NO_RETURN_KEY_FIELD_ROOTS.has(root) || pathSegments.length === 0 || pathSegments.some((segment) => segment.length === 0 || isDangerousAutomationVariableObjectKey(segment))) {
+  if (root === void 0 || !POINT_OF_NO_RETURN_KEY_FIELD_ROOTS.has(root) || pathSegments.length === 0 || pathSegments.some((segment) => segment.length === 0 || isUnsafeObjectKey(segment))) {
     return void 0;
   }
   return segments;
@@ -13440,7 +13486,7 @@ import { z as z16 } from "zod";
 
 // ../common/dist/src/zod-schemas/output-store-binding.schema.js
 import { z as z15 } from "zod";
-var outputStorePathSchema = z15.string().regex(/^store\.[$A-Z_a-z][\w$]*(?:\.[$A-Z_a-z][\w$]*)*$/u, "Data Store destination must be a fully qualified path such as store.patient.name.");
+var outputStorePathSchema = z15.string().regex(/^store\.[^\s.]+(?:\.[^\s.]+)*$/u, "Data Store destination must be a fully qualified path such as store.patient.name.");
 
 // ../common/dist/src/zod-schemas/api-tool.schema.js
 var methodsWithBody = new Set(ApiMethodsWithBody);
@@ -13481,7 +13527,7 @@ var apiOutputStorePathSchema = outputStorePathSchema.describe("Fully qualified D
 var apiOutputStoreBindingShape = {
   jmesPath: z16.string().trim().min(1, "JMESPath is required. Use @ to select the entire response.").describe("JMESPath expression evaluated against the raw API response. Use @ to select the entire response."),
   storePath: apiOutputStorePathSchema,
-  arrayMode: z16.enum(["append", "appendList", "replace"]).optional().describe("Required for newly authored array destinations: append adds exactly one item, appendList adds multiple items, and replace sets the complete list. Omit for scalar destinations. Legacy omitted array modes still append at runtime.")
+  arrayMode: z16.enum(["append", "appendList", "replace"]).optional().describe("Required for newly authored array destinations: append adds exactly one item, appendList adds multiple items, and replace sets the complete list. Omit for scalar and Object destinations; Object values replace the complete object. Legacy omitted array modes still append at runtime.")
 };
 var apiOutputStoreBindingObjectSchema = z16.object(apiOutputStoreBindingShape);
 var apiOutputStoreBindingAuthoringSchema = z16.object(apiOutputStoreBindingShape).strict();
@@ -13824,7 +13870,7 @@ var outputStoreSourcePathRegex = /^[$A-Z_a-z][\w$]*(?:\.[$A-Z_a-z][\w$]*)*$/u;
 var outputStoreBindingSchema = z19.object({
   sourcePath: z19.string().refine((sourcePath) => sourcePath === "$" || outputStoreSourcePathRegex.test(sourcePath), 'Output source path must be "$" or a dot path such as patient.name.').describe("Dot path of the node output value to write."),
   storePath: outputStorePathSchema.describe("Fully qualified Data Store path that receives the output."),
-  arrayMode: z19.enum(["append", "appendList", "replace"]).optional().describe("Required for newly authored array destinations: append adds exactly one item, appendList adds multiple items, and replace sets the complete list. Omit for scalar destinations. Legacy omitted array modes still append at runtime.")
+  arrayMode: z19.enum(["append", "appendList", "replace"]).optional().describe("Required for newly authored array destinations: append adds exactly one item, appendList adds multiple items, and replace sets the complete list. Omit for scalar and Object destinations; Object values replace the complete object. Legacy omitted array modes still append at runtime.")
 }).describe("Maps one node output value to one Data Store destination.");
 function validateUniqueOutputStoreBindings(bindings, ctx) {
   const sourcePaths = /* @__PURE__ */ new Set();
@@ -13976,12 +14022,67 @@ var draftAgentConfigSchema = z19.preprocess((data) => {
 }, draftAgentConfigSchemaUnion).describe("Draft agent configuration. Matches authored validation for most agent types, but allows incomplete decision agents during draft saves.");
 var DEFAULT_AGENT_CONFIG = agentConfigSchema.parse({});
 
-// ../common/dist/src/zod-schemas/automation-run-config.schema.js
+// ../common/dist/src/zod-schemas/automation-store-migration-analyzer.schema.js
 import { z as z20 } from "zod";
-var automationRunResolvedRunSettingsSchema = z20.object({
+var automationStoreMigrationMappingSchema = z20.object({
+  sourceAutomationId: z20.string().uuid(),
+  sourceAgentId: z20.string().uuid().optional(),
+  sourceKind: z20.enum(["input", "output", "sharedInput"]),
+  sourceKey: z20.string().min(1),
+  logicalValueId: z20.string().min(1).optional(),
+  outputBindingSourcePath: z20.string().min(1).optional(),
+  handling: z20.enum(["store", "keepLocal", "remove"]),
+  reason: z20.string().min(1),
+  targetStorePath: z20.string().min(1).optional(),
+  population: z20.enum([
+    "default",
+    "initialStore",
+    "outputStoreBinding",
+    "updateStoreValues"
+  ]).optional(),
+  writerAgentId: z20.string().uuid().optional(),
+  isWorkItemIdentity: z20.boolean().optional(),
+  conversion: z20.string().min(1).optional()
+});
+var automationStoreMigrationWritePolicySchema = z20.object({
+  automationId: z20.string().uuid(),
+  path: z20.string().min(1),
+  writerAgentIds: z20.array(z20.string().uuid()).min(1),
+  coordination: z20.enum([
+    "singleWriter",
+    "mutuallyExclusiveBranches",
+    "orderedScalarOverwrite",
+    "disjointArrayItems"
+  ]),
+  arrayRetryStrategy: z20.enum(["notApplicable", "readBeforeAppend"]),
+  rationale: z20.string().min(1)
+});
+var automationStoreMigrationComparisonVersionSchema = z20.object({
+  automationId: z20.string().uuid(),
+  automationVersionId: z20.string().uuid(),
+  role: z20.enum(["beforeMigration", "afterMigration"]),
+  slotLifecycle: z20.enum(["existing", "introduced"]).default("existing"),
+  slot: z20.string().min(1)
+});
+var automationStoreMigrationComparisonSchema = z20.object({
+  versions: z20.array(automationStoreMigrationComparisonVersionSchema).min(1).max(40)
+});
+var automationStoreMigrationAnalyzerInputSchema = z20.object({
+  mode: z20.enum(["audit", "compare", "auditRuntimeEvidence"]).describe("audit reads current drafts; compare reads exact saved versions; auditRuntimeEvidence reads only caller-supplied existing runs and their exact saved versions."),
+  automationIds: z20.array(z20.string().uuid()).max(20).default([]).describe("Starting draft automation IDs for audit. The analyzer follows authored queue targets within a bounded organization-scoped traversal."),
+  comparison: automationStoreMigrationComparisonSchema.nullable().default(null).describe("Exact before/after saved-version pairs for compare. Introduced slots require only an afterMigration version."),
+  mappings: z20.array(automationStoreMigrationMappingSchema).default([]),
+  storeWritePolicies: z20.array(automationStoreMigrationWritePolicySchema).max(100).default([]),
+  runIds: z20.array(z20.string().uuid()).max(20).default([]).describe("Existing run IDs to inspect only in auditRuntimeEvidence mode. The analyzer never creates or starts runs."),
+  workItem: z20.string().default("").describe("Optional name for the business work item being migrated.")
+});
+
+// ../common/dist/src/zod-schemas/automation-run-config.schema.js
+import { z as z21 } from "zod";
+var automationRunResolvedRunSettingsSchema = z21.object({
   environmentOptions: runSettingsEnvironmentOptionsSchema.describe("Canonical run-settings-owned environment settings snapshotted onto the automation run when it starts in runSettings mode. Agent-owned fields such as startingUrl and maxMediaToIncludeInMemory are intentionally ignored at runtime."),
   resourcePools: resourcePoolsSchema.describe("Canonical run-settings-owned resource pools snapshotted onto the automation run when it starts in runSettings mode. Slot assignment and queue status use this only when resolvedRunSettingsSource is runSettings."),
-  skipBrowserDebuggerPauses: z20.boolean().optional().describe("Canonical run-settings-owned browser session startup setting snapshotted onto the automation run when it starts in runSettings mode.")
+  skipBrowserDebuggerPauses: z21.boolean().optional().describe("Canonical run-settings-owned browser session startup setting snapshotted onto the automation run when it starts in runSettings mode.")
 });
 var CONSISTENCY_CHECK_COUNT_MAX = 50;
 var NETWORK_TRAFFIC_CAPTURE_RECORD_MODES = [
@@ -13989,18 +14090,18 @@ var NETWORK_TRAFFIC_CAPTURE_RECORD_MODES = [
   "explicit"
 ];
 var DEFAULT_NETWORK_TRAFFIC_CAPTURE_RECORD_MODE = "implicit";
-var networkTrafficCaptureSchema = z20.discriminatedUnion("mode", [
-  z20.object({
-    mode: z20.literal("record"),
-    recordMode: z20.enum(NETWORK_TRAFFIC_CAPTURE_RECORD_MODES).optional().default(DEFAULT_NETWORK_TRAFFIC_CAPTURE_RECORD_MODE).describe("Whether this recording was created implicitly by automation infrastructure or explicitly requested by the user. Explicit recordings are retained longer.")
+var networkTrafficCaptureSchema = z21.discriminatedUnion("mode", [
+  z21.object({
+    mode: z21.literal("record"),
+    recordMode: z21.enum(NETWORK_TRAFFIC_CAPTURE_RECORD_MODES).optional().default(DEFAULT_NETWORK_TRAFFIC_CAPTURE_RECORD_MODE).describe("Whether this recording was created implicitly by automation infrastructure or explicitly requested by the user. Explicit recordings are retained longer.")
   }).describe("Record network traffic for this run. The recording ID is generated from the automation run ID."),
-  z20.object({
-    mode: z20.literal("replay"),
-    recordingId: z20.uuid().describe("Recording ID from a previous record run in the same organization.")
+  z21.object({
+    mode: z21.literal("replay"),
+    recordingId: z21.uuid().describe("Recording ID from a previous record run in the same organization.")
   }).describe("Replay network traffic from a previous recording.")
 ]).describe("Optional network traffic capture mode for this run. Applies to browser provider traffic and supported agent tool HTTP traffic, including API tool calls and provider-authenticated helper requests.");
-var automationRunSlaTypeSchema = z20.enum(["all"]);
-var automationRunSlaTimestampSchema = z20.iso.datetime();
+var automationRunSlaTypeSchema = z21.enum(["all"]);
+var automationRunSlaTimestampSchema = z21.iso.datetime();
 function refineAutomationRunSlaTimestampOrder(sla, ctx) {
   const startedAtMs = Date.parse(sla.startedAt);
   const breachesAtMs = Date.parse(sla.breachesAt);
@@ -14030,31 +14131,31 @@ function refineAutomationRunSlaTimestampOrder(sla, ctx) {
     });
   }
 }
-var automationRunSlaSchema = z20.object({
+var automationRunSlaSchema = z21.object({
   startedAt: automationRunSlaTimestampSchema.describe("ISO timestamp when SLA tracking started for this run."),
   highRiskAt: automationRunSlaTimestampSchema.optional().describe("Optional ISO timestamp when this run should be considered at high risk of breaching its SLA."),
   breachesAt: automationRunSlaTimestampSchema.describe("ISO timestamp when this run breaches its SLA."),
   type: automationRunSlaTypeSchema.optional().default("all").describe("SLA policy type that applies to this automation run.")
 }).superRefine(refineAutomationRunSlaTimestampOrder).describe("Optional service-level timing metadata for queueing and runtime consumers of this automation run.");
-var automationRunConfigBaseSchema = z20.object({
-  approvalMode: z20.enum(["HUMAN_APPROVAL", "OFF"]).default("OFF"),
-  consistencyCheckCount: z20.number().int().nonnegative().max(CONSISTENCY_CHECK_COUNT_MAX).nullable().default(null),
-  settingsSourceAgentId: z20.uuid().nullable().optional().describe("Optional provenance/debug field recording which top-level agent supplied canonical run settings when the run started. Runtime consumers must not use this as a live pointer once resolvedRunSettingsSource has been decided."),
-  startInTakeOverMode: z20.boolean().default(false).describe("When true, create and prepare the remote session, then pause until a human manually starts the agent."),
-  captureActions: z20.boolean().default(false).describe("When true, attach an action recording while a draft run is paused in takeover mode."),
-  runDraftQueuedAgents: z20.boolean().optional().describe("Draft-run-only option. When false, queue-agent actions in the draft run report success without starting downstream queued draft child runs. Omit or true preserves queueing."),
-  allowPointOfNoReturnOverride: z20.boolean().optional().describe("Internal rerun authorization. When true, the rerun and its queued descendants may proceed past a point-of-no-return crossing owned by an earlier run."),
-  pointOfNoReturnGateEnabled: z20.literal(true).optional().describe("Infrastructure-owned rollout marker. PONR is enforced only for run trees created after the gate rollout."),
+var automationRunConfigBaseSchema = z21.object({
+  approvalMode: z21.enum(["HUMAN_APPROVAL", "OFF"]).default("OFF"),
+  consistencyCheckCount: z21.number().int().nonnegative().max(CONSISTENCY_CHECK_COUNT_MAX).nullable().default(null),
+  settingsSourceAgentId: z21.uuid().nullable().optional().describe("Optional provenance/debug field recording which top-level agent supplied canonical run settings when the run started. Runtime consumers must not use this as a live pointer once resolvedRunSettingsSource has been decided."),
+  startInTakeOverMode: z21.boolean().default(false).describe("When true, create and prepare the remote session, then pause until a human manually starts the agent."),
+  captureActions: z21.boolean().default(false).describe("When true, attach an action recording while a draft run is paused in takeover mode."),
+  runDraftQueuedAgents: z21.boolean().optional().describe("Draft-run-only option. When false, queue-agent actions in the draft run report success without starting downstream queued draft child runs. Omit or true preserves queueing."),
+  allowPointOfNoReturnOverride: z21.boolean().optional().describe("Internal rerun authorization. When true, the rerun and its queued descendants may proceed past a point-of-no-return crossing owned by an earlier run."),
+  pointOfNoReturnGateEnabled: z21.literal(true).optional().describe("Infrastructure-owned rollout marker. PONR is enforced only for run trees created after the gate rollout."),
   sla: automationRunSlaSchema.optional(),
   networkTrafficCapture: networkTrafficCaptureSchema.optional(),
-  networkTrafficCaptureExplicitlyDisabled: z20.literal(true).optional().describe("Infrastructure-owned marker indicating that network traffic capture was explicitly disabled for this run. When present, runtime policy resolution must not enable capture."),
-  implicitNetworkTrafficRecordingDecision: z20.object({
-    enabled: z20.boolean()
+  networkTrafficCaptureExplicitlyDisabled: z21.literal(true).optional().describe("Infrastructure-owned marker indicating that network traffic capture was explicitly disabled for this run. When present, runtime policy resolution must not enable capture."),
+  implicitNetworkTrafficRecordingDecision: z21.object({
+    enabled: z21.boolean()
   }).optional().describe("Infrastructure-owned snapshot of the implicit network traffic recording flag decision. Runtime retries use this to avoid re-evaluating LaunchDarkly for the same run."),
   resolvedRunSettings: automationRunResolvedRunSettingsSchema.optional().describe("Canonical run settings snapshotted onto the automation run at creation time. Present only for runSettings mode; legacyConfig mode intentionally resolves runtime settings from each current agent config instead of storing a misleading snapshot."),
   queueResourcePools: resourcePoolsSchema.optional().describe("Canonical deduped resource-pool requirements snapshotted for queue and slot assignment. Present on new runs so assignment does not recompute requirements from mutable agent config."),
   credentialVariableResourcePools: resourcePoolsSchema.optional().describe("Additional resource pools selected through credential-valued automation variables. These are additive queue requirements and do not change whether the run uses runSettings or legacyConfig as its runtime settings source."),
-  resolvedRunSettingsSource: z20.enum(["runSettings", "legacyConfig"]).optional().describe("Runtime mode decided at run creation. runSettings means resolvedRunSettings is canonical for browser/session/resource-pool behaviour; legacyConfig means runtime consumers must use current agent legacy config fields.")
+  resolvedRunSettingsSource: z21.enum(["runSettings", "legacyConfig"]).optional().describe("Runtime mode decided at run creation. runSettings means resolvedRunSettings is canonical for browser/session/resource-pool behaviour; legacyConfig means runtime consumers must use current agent legacy config fields.")
 });
 var automationRunConfigSchema = automationRunConfigBaseSchema.superRefine((config, ctx) => {
   if (config.networkTrafficCaptureExplicitlyDisabled === true && config.networkTrafficCapture !== void 0) {
@@ -14079,8 +14180,69 @@ var automationRunStartConfigSchema = automationRunConfigBaseSchema.omit({
   networkTrafficCapture: networkTrafficCaptureSchema.nullable().optional().describe("Network traffic capture preference for this run. Omit to apply the implicit recording policy, pass null to explicitly disable capture, or pass a record/replay config to explicitly enable capture.")
 });
 
+// ../common/dist/src/utils/custom-instructions-command.util.js
+var MAX_CUSTOM_COMMAND_COUNT = 1;
+var MAX_CUSTOM_INSTRUCTIONS_LENGTH = 280;
+var STANDARD_COMMAND_NAMES = [
+  "callSpecializedAgent",
+  "checkpoint",
+  "click",
+  "clickFill",
+  "ifElse",
+  "loop",
+  "navigateTo",
+  "pressKeys",
+  "queueAgents",
+  "reportStop",
+  "somFilter"
+];
+function createInvalidValueError(message) {
+  const error = new Error(`INVALID_VALUE: ${message}`);
+  error.name = "INVALID_VALUE";
+  return error;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getCustomInstructions(command) {
+  const commandArguments = command["arguments"];
+  if (!isRecord2(commandArguments)) {
+    return "";
+  }
+  const { instructions } = commandArguments;
+  return typeof instructions === "string" ? instructions.trim() : "";
+}
+function getMentionedStandardCommand(instructions) {
+  const normalizedInstructions = instructions.toLowerCase();
+  return STANDARD_COMMAND_NAMES.find((commandName) => normalizedInstructions.includes(commandName.toLowerCase())) ?? null;
+}
+function assertCustomInstructionsCommand({ commands, path: path7 }) {
+  const customCommands = commands.flatMap((command, commandIndex) => command["commandName"] === "custom" ? [{ command, path: `${path7}[${commandIndex.toString()}]` }] : []);
+  if (customCommands.length === 0) {
+    return;
+  }
+  if (customCommands.length > MAX_CUSTOM_COMMAND_COUNT) {
+    throw createInvalidValueError(`${path7} contains ${customCommands.length.toString()} custom commands. Use at most one short custom command per agent. Split policy, decision, outreach, and multi-step work into catalog commands or child agents instead.`);
+  }
+  const [customCommand] = customCommands;
+  if (!customCommand) {
+    return;
+  }
+  const instructions = getCustomInstructions(customCommand.command);
+  if (instructions.length === 0) {
+    throw createInvalidValueError(`${customCommand.path}.arguments.instructions must be a non-empty string for custom commands.`);
+  }
+  if (instructions.length > MAX_CUSTOM_INSTRUCTIONS_LENGTH) {
+    throw createInvalidValueError(`${customCommand.path}.arguments.instructions is ${instructions.length.toString()} characters. Custom commands must be short single-action instructions (max ${MAX_CUSTOM_INSTRUCTIONS_LENGTH.toString()} chars). Move policy/template/context text into description, inputSchema, or child agents, and express executable work with catalog commands.`);
+  }
+  const mentionedCommand = getMentionedStandardCommand(instructions);
+  if (mentionedCommand !== null) {
+    throw createInvalidValueError(`${customCommand.path}.arguments.instructions mentions "${mentionedCommand}". Use the "${mentionedCommand}" catalog command directly instead of wrapping it in custom prose.`);
+  }
+}
+
 // ../mcp-registry/src/operation-specs.ts
-import { z as z21 } from "zod";
+import { z as z23 } from "zod";
 
 // ../mcp-registry/src/operation-spec.ts
 function stripLeadingGraphqlComments(document) {
@@ -14184,7 +14346,79 @@ function jsonOption({
     valueType: "json"
   };
 }
-var jsonObjectSchema = z21.record(z21.string(), z21.unknown());
+var jsonObjectSchema = z23.record(z23.string(), z23.unknown());
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validateCustomInstructionsCommands({
+  commands,
+  ctx,
+  path: path7
+}) {
+  if (!Array.isArray(commands)) {
+    return;
+  }
+  const validationResult = fromThrowable(() => {
+    assertCustomInstructionsCommand({
+      commands: commands.map((command) => isRecord3(command) ? command : {}),
+      path: path7.join(".").replaceAll(/\.(?<index>\d+)/gu, "[$<index>]")
+    });
+  }, "invalid-custom-instructions-command");
+  if (isErr(validationResult)) {
+    ctx.addIssue({
+      code: "custom",
+      message: `${getErrorMessage2(validationResult.error.cause)} Run mgcl catalog commands to find the standard command for this work.`,
+      path: path7
+    });
+  }
+}
+var automationPatchOperationsSchema = z23.array(z23.unknown()).min(1).superRefine((operations, ctx) => {
+  for (const [operationIndex, operation] of operations.entries()) {
+    if (!isRecord3(operation)) {
+      continue;
+    }
+    const setCommands = operation["setAgentInstructionsCommands"];
+    if (!isRecord3(setCommands)) {
+      continue;
+    }
+    validateCustomInstructionsCommands({
+      commands: setCommands["instructionsCommands"],
+      ctx,
+      path: [
+        "operations",
+        operationIndex,
+        "setAgentInstructionsCommands",
+        "instructionsCommands"
+      ]
+    });
+  }
+});
+function automationInputSchema(agentKeys) {
+  return jsonObjectSchema.superRefine((input, ctx) => {
+    for (const agentKey of agentKeys) {
+      const agents = input[agentKey];
+      if (!Array.isArray(agents)) {
+        continue;
+      }
+      for (const [agentIndex, agent] of agents.entries()) {
+        if (!isRecord3(agent)) {
+          continue;
+        }
+        validateCustomInstructionsCommands({
+          commands: agent["instructionsCommands"],
+          ctx,
+          path: [agentKey, agentIndex, "instructionsCommands"]
+        });
+      }
+    }
+  });
+}
+var createAutomationInputSchema = automationInputSchema(["newAgents"]);
+var updateAutomationInputSchema = automationInputSchema([
+  "newAgents",
+  "updatedAgents"
+]);
+var COMMAND_CATALOG_HELP = "When authoring raw instructionsCommands, run mgcl catalog commands and prefer a standard command.";
 var agentBrowserProviderOptionsSelection = `            browserbase {
               advancedStealth
               contextId
@@ -14277,11 +14511,51 @@ var agentLimitationsSelection = `      limitations {
         allowedUrlRegexes
       }`;
 var operationSpecs = [
+  createOperationSpec({
+    operationName: "GetCaptureContext",
+    kind: "query",
+    inputSchema: z23.object({
+      automationId: z23.string().min(1).optional(),
+      recordingId: z23.string().min(1).optional()
+    }).refine(
+      ({ automationId, recordingId }) => [automationId, recordingId].some((value) => value !== void 0),
+      { message: "Provide --automation-id or --recording-id." }
+    ),
+    cli: {
+      name: "get-capture-context",
+      path: ["capture-context", "get"],
+      description: "Fetch raw browser events and screenshots from a Capture Mode recording.",
+      resultKey: "captureContext",
+      options: [
+        stringOption({
+          inputKey: "automationId",
+          flagName: "automation-id",
+          description: "Automation ID whose newest usable Capture Mode recording to fetch."
+        }),
+        stringOption({
+          inputKey: "recordingId",
+          flagName: "recording-id",
+          description: "Exact Capture Mode recording ID to fetch."
+        })
+      ]
+    },
+    mcp: { fileName: "captureContext.graphql" },
+    document: `# Fetch raw Capture Mode context with inline screenshots
+query GetCaptureContext($automationId: ID, $recordingId: ID) {
+  captureContext(
+    automationId: $automationId
+    recordingId: $recordingId
+  ) {
+    metadata
+    rawEvents
+  }
+}`
+  }),
   createOperationSpec({
     operationName: "GetAgents",
     kind: "query",
-    inputSchema: z21.object({
-      ids: z21.array(z21.string().min(1)).min(1)
+    inputSchema: z23.object({
+      ids: z23.array(z23.string().min(1)).min(1)
     }),
     cli: {
       name: "get-agents",
@@ -14342,9 +14616,9 @@ ${agentLimitationsSelection}
   createOperationSpec({
     operationName: "GetAgentVersion",
     kind: "query",
-    inputSchema: z21.object({
-      agentId: z21.string().min(1),
-      versionId: z21.string().min(1)
+    inputSchema: z23.object({
+      agentId: z23.string().min(1),
+      versionId: z23.string().min(1)
     }),
     cli: {
       name: "get-agent-version",
@@ -14407,8 +14681,8 @@ ${agentLimitationsSelection}
   createOperationSpec({
     operationName: "GetAgentVersions",
     kind: "query",
-    inputSchema: z21.object({
-      agentId: z21.string().min(1)
+    inputSchema: z23.object({
+      agentId: z23.string().min(1)
     }),
     cli: {
       name: "get-agent-versions",
@@ -14442,10 +14716,10 @@ query GetAgentVersions($agentId: ID!) {
   createOperationSpec({
     operationName: "DiffAgentVersion",
     kind: "query",
-    inputSchema: z21.object({
-      agentId: z21.string().min(1),
-      versionId: z21.string().min(1),
-      compareVersionId: z21.string().min(1).optional()
+    inputSchema: z23.object({
+      agentId: z23.string().min(1),
+      versionId: z23.string().min(1),
+      compareVersionId: z23.string().min(1).optional()
     }),
     cli: {
       name: "diff-agent-version",
@@ -14499,8 +14773,8 @@ query DiffAgentVersion(
   createOperationSpec({
     operationName: "GetAgentRun",
     kind: "query",
-    inputSchema: z21.object({
-      id: z21.string().min(1)
+    inputSchema: z23.object({
+      id: z23.string().min(1)
     }),
     cli: {
       name: "get-agent-run",
@@ -14536,8 +14810,8 @@ query GetAgentRun($id: ID!) {
   createOperationSpec({
     operationName: "GetAutomationAgents",
     kind: "query",
-    inputSchema: z21.object({
-      ids: z21.array(z21.string().min(1)).min(1)
+    inputSchema: z23.object({
+      ids: z23.array(z23.string().min(1)).min(1)
     }),
     cli: {
       name: "get-automation-agents",
@@ -14580,8 +14854,8 @@ query GetAutomationAgents($ids: [ID!]!) {
   createOperationSpec({
     operationName: "GetAutomationDiffFromPublished",
     kind: "query",
-    inputSchema: z21.object({
-      automationId: z21.string().min(1)
+    inputSchema: z23.object({
+      automationId: z23.string().min(1)
     }),
     cli: {
       name: "get-automation-diff-from-published",
@@ -14614,9 +14888,9 @@ query GetAutomationDiffFromPublished($automationId: ID!) {
   createOperationSpec({
     operationName: "GetAutomationDiffVersions",
     kind: "query",
-    inputSchema: z21.object({
-      baseVersionId: z21.string().min(1),
-      targetVersionId: z21.string().min(1)
+    inputSchema: z23.object({
+      baseVersionId: z23.string().min(1),
+      targetVersionId: z23.string().min(1)
     }),
     cli: {
       name: "get-automation-diff-versions",
@@ -14657,10 +14931,10 @@ query GetAutomationDiffVersions($baseVersionId: ID!, $targetVersionId: ID!) {
   createOperationSpec({
     operationName: "GetAutomationVersionJson",
     kind: "query",
-    inputSchema: z21.object({
-      versionId: z21.string().min(1),
-      paths: z21.array(z21.string().min(1)).optional(),
-      format: z21.enum(["normalized", "full", "export"]).optional()
+    inputSchema: z23.object({
+      versionId: z23.string().min(1),
+      paths: z23.array(z23.string().min(1)).optional(),
+      format: z23.enum(["normalized", "full", "export"]).optional()
     }),
     cli: {
       name: "get-automation-version-json",
@@ -14695,8 +14969,8 @@ query GetAutomationVersionJson($versionId: ID!, $paths: [String!], $format: Stri
   createOperationSpec({
     operationName: "GetAutomationVersionJsonSkeleton",
     kind: "query",
-    inputSchema: z21.object({
-      versionId: z21.string().min(1)
+    inputSchema: z23.object({
+      versionId: z23.string().min(1)
     }),
     cli: {
       name: "get-automation-version-json-skeleton",
@@ -14721,8 +14995,8 @@ query GetAutomationVersionJsonSkeleton($versionId: ID!) {
   createOperationSpec({
     operationName: "GetAutomationRun",
     kind: "query",
-    inputSchema: z21.object({
-      id: z21.string().min(1)
+    inputSchema: z23.object({
+      id: z23.string().min(1)
     }),
     cli: {
       name: "get-automation-run",
@@ -14762,8 +15036,8 @@ query GetAutomationRun($id: ID!) {
   createOperationSpec({
     operationName: "GetAutomationRunAgentRuns",
     kind: "query",
-    inputSchema: z21.object({
-      automationRunId: z21.string().min(1)
+    inputSchema: z23.object({
+      automationRunId: z23.string().min(1)
     }),
     cli: {
       name: "get-automation-run-agent-runs",
@@ -14799,11 +15073,11 @@ query GetAutomationRunAgentRuns($automationRunId: ID!) {
   createOperationSpec({
     operationName: "GetAutomationRunIterations",
     kind: "query",
-    inputSchema: z21.object({
-      automationRunId: z21.string().min(1),
-      agentRunId: z21.string().min(1).optional(),
-      limit: z21.number().int().positive().optional(),
-      reverse: z21.boolean().optional()
+    inputSchema: z23.object({
+      automationRunId: z23.string().min(1),
+      agentRunId: z23.string().min(1).optional(),
+      limit: z23.number().int().positive().optional(),
+      reverse: z23.boolean().optional()
     }),
     cli: {
       name: "get-automation-run-iterations",
@@ -14867,19 +15141,70 @@ query GetAutomationRunIterations(
       screenshotMimeType
     }
   }
+}`
+  }),
+  createOperationSpec({
+    operationName: "InspectPausedAutomationStep",
+    kind: "query",
+    inputSchema: z23.object({
+      runId: z23.string().min(1)
+    }),
+    cli: {
+      name: "inspect-paused-automation-step",
+      path: ["automation-runs", "inspect-paused-step"],
+      description: "Inspect the latest persisted iteration for a paused manual-mode run.",
+      resultKey: "automationRunIterations",
+      options: [
+        stringOption({
+          inputKey: "runId",
+          flagName: "run-id",
+          description: "Automation run ID.",
+          required: true
+        })
+      ]
+    },
+    mcp: { fileName: "inspectPausedAutomationStep.graphql" },
+    document: `# Inspect the latest persisted iteration for a paused manual-mode run
+query InspectPausedAutomationStep($runId: ID!) {
+  automationRunIterations(
+    automationRunId: $runId
+    limit: 1
+    reverse: true
+  ) {
+    id
+    sequence
+    agentRunId
+    metadata
+    startedAt
+    finishedAt
+    totalDurationMs
+    llmResponseDurationMs
+    iterationContext
+    verificationResults
+    withMarksScreenshotUrl
+    withMarksMimeType
+    memories {
+      id
+      type
+      value
+      sequence
+      screenshotUrl
+      screenshotMimeType
+    }
+  }
 }`
   }),
   createOperationSpec({
     operationName: "GetAutomationRuns",
     kind: "query",
-    inputSchema: z21.object({
-      automationId: z21.string().min(1).optional(),
-      from: z21.string().min(1).optional(),
-      status: z21.array(z21.string().min(1)).optional(),
-      invocationType: z21.array(z21.string().min(1)).optional(),
-      limit: z21.number().int().positive().optional(),
-      page: z21.number().int().nonnegative().optional(),
-      to: z21.string().min(1).optional()
+    inputSchema: z23.object({
+      automationId: z23.string().min(1).optional(),
+      from: z23.string().min(1).optional(),
+      status: z23.array(z23.string().min(1)).optional(),
+      invocationType: z23.array(z23.string().min(1)).optional(),
+      limit: z23.number().int().positive().optional(),
+      page: z23.number().int().nonnegative().optional(),
+      to: z23.string().min(1).optional()
     }),
     cli: {
       name: "get-automation-runs",
@@ -14961,8 +15286,8 @@ query GetAutomationRuns(
   createOperationSpec({
     operationName: "ListAutomations",
     kind: "query",
-    inputSchema: z21.object({
-      limit: z21.number().positive().optional(),
+    inputSchema: z23.object({
+      limit: z23.number().positive().optional(),
       order: jsonObjectSchema.optional(),
       where: jsonObjectSchema.optional()
     }),
@@ -15013,8 +15338,8 @@ query ListAutomations(
   createOperationSpec({
     operationName: "GetAutomations",
     kind: "query",
-    inputSchema: z21.object({
-      ids: z21.array(z21.string().min(1)).min(1)
+    inputSchema: z23.object({
+      ids: z23.array(z23.string().min(1)).min(1)
     }),
     cli: {
       name: "get-automations",
@@ -15057,13 +15382,83 @@ query GetAutomations($ids: [ID!]!) {
       }
     }
   }
+}`
+  }),
+  createOperationSpec({
+    operationName: "AnalyzeAutomationStoreMigration",
+    kind: "query",
+    inputSchema: automationStoreMigrationAnalyzerInputSchema,
+    cli: {
+      name: "analyze-automation-store-migration",
+      path: ["automations", "store-migration", "analyze"],
+      description: "Run read-only deterministic Store migration analysis over drafts, saved versions, or existing runs.",
+      resultKey: "automationStoreMigrationAnalysis",
+      options: [
+        stringOption({
+          inputKey: "mode",
+          flagName: "mode",
+          description: "Analysis mode: audit, compare, or auditRuntimeEvidence.",
+          required: true
+        }),
+        stringArrayOption({
+          inputKey: "automationIds",
+          flagName: "automation-ids",
+          description: "Starting draft automation IDs for audit mode."
+        }),
+        jsonOption({
+          inputKey: "comparison",
+          flagName: "comparison-json",
+          description: "Exact saved-version declaration for compare mode."
+        }),
+        jsonOption({
+          inputKey: "mappings",
+          flagName: "mappings-json",
+          description: "Legacy-value migration mapping declarations."
+        }),
+        jsonOption({
+          inputKey: "storeWritePolicies",
+          flagName: "store-write-policies-json",
+          description: "Store writer coordination policy declarations."
+        }),
+        stringArrayOption({
+          inputKey: "runIds",
+          flagName: "run-ids",
+          description: "Existing run IDs for auditRuntimeEvidence mode; no runs are created."
+        }),
+        stringOption({
+          inputKey: "workItem",
+          flagName: "work-item",
+          description: "Optional business work-item label."
+        })
+      ]
+    },
+    mcp: { fileName: "analyzeAutomationStoreMigration.graphql" },
+    document: `# Read-only deterministic analysis for Automation Store migrations.
+query AnalyzeAutomationStoreMigration(
+  $mode: String!
+  $automationIds: [ID!]!
+  $comparison: JSON
+  $mappings: JSON!
+  $storeWritePolicies: JSON!
+  $runIds: [ID!]!
+  $workItem: String!
+) {
+  automationStoreMigrationAnalysis(
+    mode: $mode
+    automationIds: $automationIds
+    comparison: $comparison
+    mappings: $mappings
+    storeWritePolicies: $storeWritePolicies
+    runIds: $runIds
+    workItem: $workItem
+  )
 }`
   }),
   createOperationSpec({
     operationName: "GetAvailableCommands",
     kind: "query",
-    inputSchema: z21.object({
-      env: z21.string().min(1)
+    inputSchema: z23.object({
+      env: z23.string().min(1)
     }),
     cli: {
       name: "get-available-commands",
@@ -15084,7 +15479,10 @@ query GetAutomations($ids: [ID!]!) {
 query GetAvailableCommands($env: AvailableCommandsEnv!) {
   availableCommands(env: $env) {
     id
+    category
     description
+    template
+    whenToUse
     requiredTool
     inputSchema
   }
@@ -15093,8 +15491,8 @@ query GetAvailableCommands($env: AvailableCommandsEnv!) {
   createOperationSpec({
     operationName: "GetAvailableModels",
     kind: "query",
-    inputSchema: z21.object({
-      agentId: z21.string().min(1)
+    inputSchema: z23.object({
+      agentId: z23.string().min(1)
     }),
     cli: {
       name: "get-available-models",
@@ -15138,9 +15536,9 @@ query GetAvailableModels($agentId: String!) {
   createOperationSpec({
     operationName: "GetAvailableTools",
     kind: "query",
-    inputSchema: z21.object({
-      env: z21.string().min(1),
-      automationId: z21.string().min(1).optional()
+    inputSchema: z23.object({
+      env: z23.string().min(1),
+      automationId: z23.string().min(1).optional()
     }),
     cli: {
       name: "get-available-tools",
@@ -15174,8 +15572,8 @@ query GetAvailableTools($env: AvailableCommandsEnv!, $automationId: String) {
   createOperationSpec({
     operationName: "GetFeatureFlagsContext",
     kind: "query",
-    inputSchema: z21.object({
-      flagKeys: z21.array(z21.string().min(1)).min(1).max(100).optional()
+    inputSchema: z23.object({
+      flagKeys: z23.array(z23.string().min(1)).min(1).max(100).optional()
     }),
     cli: {
       name: "get-feature-flags-context",
@@ -15212,7 +15610,7 @@ query GetFeatureFlagsContext($flagKeys: [String!]) {
   createOperationSpec({
     operationName: "GetAutomationWorkbenchCredentials",
     kind: "query",
-    inputSchema: z21.object({}),
+    inputSchema: z23.object({}),
     cli: {
       name: "get-automation-workbench-credentials",
       path: ["workbench", "credentials"],
@@ -15237,8 +15635,8 @@ query GetAutomationWorkbenchCredentials {
   createOperationSpec({
     operationName: "GetAutomationWorkbenchDiagnostics",
     kind: "query",
-    inputSchema: z21.object({
-      draftAutomationId: z21.string().min(1)
+    inputSchema: z23.object({
+      draftAutomationId: z23.string().min(1)
     }),
     cli: {
       name: "get-automation-workbench-diagnostics",
@@ -15303,11 +15701,11 @@ query GetAutomationWorkbenchDiagnostics($draftAutomationId: ID!) {
   createOperationSpec({
     operationName: "GetAutomationWorkbenchRunTrace",
     kind: "query",
-    inputSchema: z21.object({
-      automationRunId: z21.string().min(1),
-      agentRunId: z21.string().min(1).optional(),
-      limit: z21.number().int().positive().optional(),
-      reverse: z21.boolean().optional()
+    inputSchema: z23.object({
+      automationRunId: z23.string().min(1),
+      agentRunId: z23.string().min(1).optional(),
+      limit: z23.number().int().positive().optional(),
+      reverse: z23.boolean().optional()
     }),
     cli: {
       name: "get-automation-workbench-run-trace",
@@ -15439,13 +15837,13 @@ query GetAutomationWorkbenchRunTrace(
   createOperationSpec({
     operationName: "GetAutomationWorkbenchAwaitRunCompletion",
     kind: "query",
-    inputSchema: z21.object({
-      automationRunId: z21.string().min(1),
-      timeoutMs: z21.number().int().min(1e3).max(6e4).optional(),
-      sinceSequence: z21.number().int().min(0).optional(),
-      agentRunId: z21.string().min(1).optional(),
-      limit: z21.number().int().positive().optional(),
-      reverse: z21.boolean().optional()
+    inputSchema: z23.object({
+      automationRunId: z23.string().min(1),
+      timeoutMs: z23.number().int().min(1e3).max(6e4).optional(),
+      sinceSequence: z23.number().int().min(0).optional(),
+      agentRunId: z23.string().min(1).optional(),
+      limit: z23.number().int().positive().optional(),
+      reverse: z23.boolean().optional()
     }),
     cli: {
       name: "await-automation-workbench-run-completion",
@@ -15599,11 +15997,11 @@ query GetAutomationWorkbenchAwaitRunCompletion(
   createOperationSpec({
     operationName: "GetAutomationWorkbenchSchemaSuggestions",
     kind: "query",
-    inputSchema: z21.object({
-      automationRunId: z21.string().min(1),
-      draftAutomationId: z21.string().min(1).optional(),
-      minConfidence: z21.number().min(0).max(1).optional(),
-      includeSensitive: z21.boolean().optional()
+    inputSchema: z23.object({
+      automationRunId: z23.string().min(1),
+      draftAutomationId: z23.string().min(1).optional(),
+      minConfidence: z23.number().min(0).max(1).optional(),
+      includeSensitive: z23.boolean().optional()
     }),
     cli: {
       name: "get-automation-workbench-schema-suggestions",
@@ -15671,8 +16069,8 @@ query GetAutomationWorkbenchSchemaSuggestions(
   createOperationSpec({
     operationName: "CreateAutomation",
     kind: "mutation",
-    inputSchema: z21.object({
-      input: jsonObjectSchema
+    inputSchema: z23.object({
+      input: createAutomationInputSchema
     }),
     cli: {
       name: "create-automation",
@@ -15683,7 +16081,7 @@ query GetAutomationWorkbenchSchemaSuggestions(
         jsonOption({
           inputKey: "input",
           flagName: "input-json",
-          description: "CreateAutomationInput payload.",
+          description: `CreateAutomationInput payload. ${COMMAND_CATALOG_HELP}`,
           required: true
         })
       ]
@@ -15708,7 +16106,7 @@ mutation CreateAutomation($input: CreateAutomationInput!) {
   createOperationSpec({
     operationName: "GetGraphqlSchema",
     kind: "query",
-    inputSchema: z21.object({}),
+    inputSchema: z23.object({}),
     cli: {
       name: "get-graphql-schema",
       path: ["graphql", "schema"],
@@ -15724,13 +16122,65 @@ mutation CreateAutomation($input: CreateAutomationInput!) {
 # reuse cached results.
 query GetGraphqlSchema {
   graphqlSchema
+}`
+  }),
+  createOperationSpec({
+    operationName: "ApproveAutomationStep",
+    kind: "mutation",
+    inputSchema: z23.object({
+      runId: z23.string().min(1)
+    }),
+    cli: {
+      name: "approve-automation-step",
+      path: ["automation-runs", "approve-step"],
+      description: "Approve the proposed step for a paused manual-mode run.",
+      resultKey: "approveAutomationStep",
+      options: [
+        stringOption({
+          inputKey: "runId",
+          flagName: "run-id",
+          description: "Automation run ID.",
+          required: true
+        })
+      ]
+    },
+    mcp: { fileName: "approveAutomationStep.graphql" },
+    document: `# Approve the proposed step for a paused manual-mode run
+mutation ApproveAutomationStep($runId: ID!) {
+  approveAutomationStep(automationRunId: $runId, retry: false)
+}`
+  }),
+  createOperationSpec({
+    operationName: "RetryAutomationStep",
+    kind: "mutation",
+    inputSchema: z23.object({
+      runId: z23.string().min(1)
+    }),
+    cli: {
+      name: "retry-automation-step",
+      path: ["automation-runs", "retry-step"],
+      description: "Retry the proposed step after saving a material change to its agent.",
+      resultKey: "approveAutomationStep",
+      options: [
+        stringOption({
+          inputKey: "runId",
+          flagName: "run-id",
+          description: "Automation run ID.",
+          required: true
+        })
+      ]
+    },
+    mcp: { fileName: "retryAutomationStep.graphql" },
+    document: `# Retry the proposed step after saving a material change to its agent
+mutation RetryAutomationStep($runId: ID!) {
+  approveAutomationStep(automationRunId: $runId, retry: true)
 }`
   }),
   createOperationSpec({
     operationName: "PauseAutomationRun",
     kind: "mutation",
-    inputSchema: z21.object({
-      automationRunId: z21.string().min(1)
+    inputSchema: z23.object({
+      automationRunId: z23.string().min(1)
     }),
     cli: {
       name: "pause-automation-run",
@@ -15755,11 +16205,11 @@ mutation PauseAutomationRun($automationRunId: ID!) {
   createOperationSpec({
     operationName: "RerunAutomation",
     kind: "mutation",
-    inputSchema: z21.object({
-      automationRunId: z21.string().min(1),
-      additionalPrompt: z21.string().min(1).optional(),
-      idempotencyKey: z21.string().min(1),
-      allowPointOfNoReturnOverride: z21.boolean().optional()
+    inputSchema: z23.object({
+      automationRunId: z23.string().min(1),
+      additionalPrompt: z23.string().min(1).optional(),
+      idempotencyKey: z23.string().min(1),
+      allowPointOfNoReturnOverride: z23.boolean().optional()
     }),
     cli: {
       name: "rerun-automation",
@@ -15814,9 +16264,9 @@ mutation RerunAutomation(
   createOperationSpec({
     operationName: "ResumeAutomationRun",
     kind: "mutation",
-    inputSchema: z21.object({
-      automationRunId: z21.string().min(1),
-      message: z21.string().min(1).optional()
+    inputSchema: z23.object({
+      automationRunId: z23.string().min(1),
+      message: z23.string().min(1).optional()
     }),
     cli: {
       name: "resume-automation-run",
@@ -15846,15 +16296,15 @@ mutation ResumeAutomationRun($automationRunId: ID!, $message: String) {
   createOperationSpec({
     operationName: "RunDraftAutomation",
     kind: "mutation",
-    inputSchema: z21.object({
-      draftAutomationId: z21.string().min(1),
-      agentId: z21.string().min(1),
-      idempotencyKey: z21.string().min(1),
-      input: z21.unknown().optional(),
-      initialStore: z21.record(z21.string(), z21.unknown()).optional(),
+    inputSchema: z23.object({
+      draftAutomationId: z23.string().min(1),
+      agentId: z23.string().min(1),
+      idempotencyKey: z23.string().min(1),
+      input: z23.unknown().optional(),
+      initialStore: z23.record(z23.string(), z23.unknown()).optional(),
       config: automationRunStartConfigSchema.partial().passthrough().optional(),
-      additionalPrompt: z21.string().min(1).optional(),
-      consistencyCheckCount: z21.number().int().optional()
+      additionalPrompt: z23.string().min(1).optional(),
+      consistencyCheckCount: z23.number().int().optional()
     }),
     cli: {
       name: "run-draft-automation",
@@ -15939,8 +16389,8 @@ mutation RunDraftAutomation(
   createOperationSpec({
     operationName: "StopAutomationRun",
     kind: "mutation",
-    inputSchema: z21.object({
-      automationRunId: z21.string().min(1)
+    inputSchema: z23.object({
+      automationRunId: z23.string().min(1)
     }),
     cli: {
       name: "stop-automation-run",
@@ -15965,10 +16415,10 @@ mutation StopAutomationRun($automationRunId: ID!) {
   createOperationSpec({
     operationName: "PreviewAutomationPatch",
     kind: "mutation",
-    inputSchema: z21.object({
-      draftAutomationId: z21.string().min(1),
-      expectedLastSavedAt: z21.string().optional(),
-      operations: z21.array(z21.unknown()).min(1)
+    inputSchema: z23.object({
+      draftAutomationId: z23.string().min(1),
+      expectedLastSavedAt: z23.string().optional(),
+      operations: automationPatchOperationsSchema
     }),
     cli: {
       name: "preview-automation-patch",
@@ -15985,7 +16435,7 @@ mutation StopAutomationRun($automationRunId: ID!) {
         jsonOption({
           inputKey: "operations",
           flagName: "operations-json",
-          description: "Automation patch operations array using AutomationWorkbenchPatchOperationInput oneOf shape.",
+          description: `Automation patch operations array using AutomationWorkbenchPatchOperationInput oneOf shape. ${COMMAND_CATALOG_HELP}`,
           required: true
         })
       ]
@@ -16077,9 +16527,9 @@ mutation PreviewAutomationPatch(
   createOperationSpec({
     operationName: "ApplyAutomationPatch",
     kind: "mutation",
-    inputSchema: z21.object({
-      draftAutomationId: z21.string().min(1),
-      operations: z21.array(z21.unknown()).min(1)
+    inputSchema: z23.object({
+      draftAutomationId: z23.string().min(1),
+      operations: automationPatchOperationsSchema
     }),
     cli: {
       name: "apply-automation-patch",
@@ -16096,7 +16546,7 @@ mutation PreviewAutomationPatch(
         jsonOption({
           inputKey: "operations",
           flagName: "operations-json",
-          description: "Automation patch operations array using AutomationWorkbenchPatchOperationInput oneOf shape.",
+          description: `Automation patch operations array using AutomationWorkbenchPatchOperationInput oneOf shape. ${COMMAND_CATALOG_HELP}`,
           required: true
         }),
         stringOption({
@@ -16195,9 +16645,9 @@ mutation ApplyAutomationPatch(
   createOperationSpec({
     operationName: "UpdateAutomationById",
     kind: "mutation",
-    inputSchema: z21.object({
-      id: z21.string().min(1),
-      input: jsonObjectSchema
+    inputSchema: z23.object({
+      id: z23.string().min(1),
+      input: updateAutomationInputSchema
     }),
     cli: {
       name: "update-automation-by-id",
@@ -16214,7 +16664,7 @@ mutation ApplyAutomationPatch(
         jsonOption({
           inputKey: "input",
           flagName: "input-json",
-          description: "UpdateAutomationInput payload. Must include baseVersionId from a fresh read. Store schema writes are additive under config.storeSchema; use removeStoreSchemaPaths for explicit deletion or replaceStoreSchema for exact replacement.",
+          description: `UpdateAutomationInput payload. Must include baseVersionId from a fresh read. Store schema writes are additive under config.storeSchema; use removeStoreSchemaPaths for explicit deletion or replaceStoreSchema for exact replacement. ${COMMAND_CATALOG_HELP}`,
           required: true
         })
       ]
@@ -16239,7 +16689,7 @@ mutation UpdateAutomationById($id: ID!, $input: UpdateAutomationInput!) {
 import { Command as Command2, InvalidArgumentError as InvalidArgumentError2, Option as Option2 } from "commander";
 
 // src/api.ts
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 
 // src/version.ts
 import fs from "node:fs";
@@ -16266,55 +16716,55 @@ var CLI_VERSION = cliPackageVersion;
 // src/api.ts
 var OTTO_AUTHORIZATION_HEADER_NAME = "X-Otto-Authorization";
 var OTTO_AUTHORIZATION_ISSUER = "magical:otto";
-var workosOrganizationsResponseSchema = z23.object({
-  organizations: z23.array(
-    z23.object({
-      id: z23.string().min(1),
-      name: z23.string().min(1),
-      primaryDomain: z23.string().nullable().optional()
+var workosOrganizationsResponseSchema = z24.object({
+  organizations: z24.array(
+    z24.object({
+      id: z24.string().min(1),
+      name: z24.string().min(1),
+      primaryDomain: z24.string().nullable().optional()
     })
   ),
-  success: z23.boolean()
+  success: z24.boolean()
 });
-var workosUserSchema = z23.object({
-  email: z23.string().nullable(),
-  id: z23.string().min(1)
+var workosUserSchema = z24.object({
+  email: z24.string().nullable(),
+  id: z24.string().min(1)
 });
-var nangoIntegrationWireSchema = z23.object({
+var nangoIntegrationWireSchema = z24.object({
   // eslint-disable-next-line @typescript-eslint/naming-convention -- mirrors Nango REST payload
-  unique_key: z23.string().min(1)
+  unique_key: z24.string().min(1)
 }).passthrough().transform((data) => ({
   ...data,
   uniqueKey: data.unique_key
 }));
-var nangoIntegrationsResponseSchema = z23.array(nangoIntegrationWireSchema);
-var organizationAuthenticationSchema = z23.object({
-  id: z23.string().min(1),
-  type: z23.string().min(1),
-  connectionId: z23.string().nullable().optional(),
-  providerConfigKey: z23.string().nullable().optional(),
-  description: z23.string().nullable().optional(),
-  hostname: z23.string().nullable().optional()
+var nangoIntegrationsResponseSchema = z24.array(nangoIntegrationWireSchema);
+var organizationAuthenticationSchema = z24.object({
+  id: z24.string().min(1),
+  type: z24.string().min(1),
+  connectionId: z24.string().nullable().optional(),
+  providerConfigKey: z24.string().nullable().optional(),
+  description: z24.string().nullable().optional(),
+  hostname: z24.string().nullable().optional()
 }).passthrough();
-var organizationAuthenticationsResponseSchema = z23.object({
-  authentications: z23.array(organizationAuthenticationSchema),
-  success: z23.boolean()
+var organizationAuthenticationsResponseSchema = z24.object({
+  authentications: z24.array(organizationAuthenticationSchema),
+  success: z24.boolean()
 });
-var graphQlResponseSchema = z23.object({
-  data: z23.record(z23.string(), z23.unknown()).optional(),
-  errors: z23.array(
-    z23.object({
-      message: z23.string().min(1)
+var graphQlResponseSchema = z24.object({
+  data: z24.record(z24.string(), z24.unknown()).optional(),
+  errors: z24.array(
+    z24.object({
+      message: z24.string().min(1)
     })
   ).optional()
 });
-var apiErrorResponseSchema = z23.object({
-  errors: z23.array(
-    z23.object({
-      message: z23.string().min(1)
+var apiErrorResponseSchema = z24.object({
+  errors: z24.array(
+    z24.object({
+      message: z24.string().min(1)
     })
   ).optional(),
-  message: z23.string().min(1).optional()
+  message: z24.string().min(1).optional()
 });
 function getApiErrorDetail(responseBody) {
   const parsedResponse = apiErrorResponseSchema.safeParse(responseBody);
@@ -16332,7 +16782,7 @@ function getApiErrorDetail(responseBody) {
 function trimTrailingSlash(value) {
   return value.replace(/\/+$/u, "");
 }
-function isRecord2(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function decodeJwtPayload(token) {
@@ -16346,7 +16796,7 @@ function decodeJwtPayload(token) {
   if (isErr(payloadResult)) {
     return null;
   }
-  return isRecord2(payloadResult.value) ? payloadResult.value : null;
+  return isRecord4(payloadResult.value) ? payloadResult.value : null;
 }
 function isOttoAuthorizationToken(token) {
   return decodeJwtPayload(token)?.["iss"] === OTTO_AUTHORIZATION_ISSUER;
@@ -16603,10 +17053,10 @@ function requireWorkosClientId(config) {
 // src/settings.ts
 import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import path3 from "node:path";
-import { z as z24 } from "zod";
-var cliSettingsSchema = z24.object({
-  env: z24.object({
-    baseUrl: z24.url().optional()
+import { z as z25 } from "zod";
+var cliSettingsSchema = z25.object({
+  env: z25.object({
+    baseUrl: z25.url().optional()
   }).default({})
 });
 function createEmptyCliSettings() {
@@ -17208,24 +17658,24 @@ ${formatExamples("Examples", [
 // src/state.ts
 import { mkdir as mkdir2, readFile as readFile3, rm as rm3, writeFile as writeFile2 } from "node:fs/promises";
 import path5 from "node:path";
-import { z as z25 } from "zod";
-var cliAccountSchema = z25.object({
-  clientId: z25.string().min(1),
-  email: z25.string().nullable(),
-  userId: z25.string().min(1)
+import { z as z26 } from "zod";
+var cliAccountSchema = z26.object({
+  clientId: z26.string().min(1),
+  email: z26.string().nullable(),
+  userId: z26.string().min(1)
 });
-var cliOrganizationSchema = z25.object({
-  id: z25.string().min(1),
-  name: z25.string().min(1),
-  primaryDomain: z25.string().nullable().default(null)
+var cliOrganizationSchema = z26.object({
+  id: z26.string().min(1),
+  name: z26.string().min(1),
+  primaryDomain: z26.string().nullable().default(null)
 });
-var cliStateSchema = z25.object({
+var cliStateSchema = z26.object({
   account: cliAccountSchema,
-  defaultOrgId: z25.string().nullable(),
-  lastUsedOrgId: z25.string().nullable(),
-  organizations: z25.array(cliOrganizationSchema)
+  defaultOrgId: z26.string().nullable(),
+  lastUsedOrgId: z26.string().nullable(),
+  organizations: z26.array(cliOrganizationSchema)
 });
-var refreshTokenFileSchema = z25.record(z25.string(), z25.string());
+var refreshTokenFileSchema = z26.record(z26.string(), z26.string());
 function createFileStateStore(stateFilePath) {
   return {
     async clear() {
@@ -17316,37 +17766,37 @@ function buildRefreshTokenKey(account) {
 }
 
 // src/workos-auth.ts
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 var DEFAULT_DEVICE_POLL_INTERVAL_SECONDS = 5;
 function buildFormHeaders() {
   const headers = new Headers();
   headers.set("content-type", "application/x-www-form-urlencoded");
   return headers;
 }
-var deviceAuthorizationSchema = z26.object({
-  device_code: z26.string().min(1),
-  expires_in: z26.number().int().positive().optional(),
-  interval: z26.number().int().positive().optional(),
-  user_code: z26.string().min(1),
-  verification_uri: z26.url(),
-  verification_uri_complete: z26.url().optional()
+var deviceAuthorizationSchema = z27.object({
+  device_code: z27.string().min(1),
+  expires_in: z27.number().int().positive().optional(),
+  interval: z27.number().int().positive().optional(),
+  user_code: z27.string().min(1),
+  verification_uri: z27.url(),
+  verification_uri_complete: z27.url().optional()
 });
-var tokenResponseSchema = z26.object({
-  access_token: z26.string().min(1),
-  expires_in: z26.number().int().positive().optional(),
-  refresh_token: z26.string().min(1),
-  token_type: z26.string().optional()
+var tokenResponseSchema = z27.object({
+  access_token: z27.string().min(1),
+  expires_in: z27.number().int().positive().optional(),
+  refresh_token: z27.string().min(1),
+  token_type: z27.string().optional()
 });
-var tokenErrorSchema = z26.object({
-  error: z26.string().min(1),
-  error_description: z26.string().optional()
+var tokenErrorSchema = z27.object({
+  error: z27.string().min(1),
+  error_description: z27.string().optional()
 });
-var accessTokenClaimsSchema = z26.object({
-  exp: z26.number().int().positive().optional(),
-  iss: z26.string().min(1).optional(),
-  org_id: z26.string().min(1).optional(),
-  sid: z26.string().min(1).optional(),
-  sub: z26.string().min(1)
+var accessTokenClaimsSchema = z27.object({
+  exp: z27.number().int().positive().optional(),
+  iss: z27.string().min(1).optional(),
+  org_id: z27.string().min(1).optional(),
+  sid: z27.string().min(1).optional(),
+  sub: z27.string().min(1)
 });
 function createWorkosAuthClient({
   fetchFn = fetch,
@@ -17545,7 +17995,7 @@ function createCliCommanderOption(optionSpec, helpGroup) {
   }
   return nextOption;
 }
-function isRecord3(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function resolveOrganizationBySelector({
@@ -17612,7 +18062,7 @@ function collectOperationVariables(operationSpec, options) {
       parsedVariables.error.issues[0]?.message ?? "Invalid command input."
     );
   }
-  if (!isRecord3(parsedVariables.data)) {
+  if (!isRecord5(parsedVariables.data)) {
     throw new CliError("Invalid command input.");
   }
   return parsedVariables.data;