@getmagical/cli 0.8.0 → 0.9.0

package/dist/index.js

@@ -1897,13 +1897,13 @@ var require_ast = __commonJS({
         helperExpression: function helperExpression(node) {
           return node.type === "SubExpression" || (node.type === "MustacheStatement" || node.type === "BlockStatement") && !!(node.params && node.params.length || node.hash);
         },
-        scopedId: function scopedId(path20) {
-          return /^\.|this\b/.test(path20.original);
+        scopedId: function scopedId(path21) {
+          return /^\.|this\b/.test(path21.original);
         },
         // an ID is simple if it only has one part, and that part is not
         // `..` or `this`.
-        simpleId: function simpleId(path20) {
-          return path20.parts.length === 1 && !AST.helpers.scopedId(path20) && !path20.depth;
+        simpleId: function simpleId(path21) {
+          return path21.parts.length === 1 && !AST.helpers.scopedId(path21) && !path21.depth;
         }
       }
     };
@@ -2973,12 +2973,12 @@ var require_helpers2 = __commonJS({
         loc
       };
     }
-    function prepareMustache(path20, params, hash, open2, strip, locInfo) {
+    function prepareMustache(path21, params, hash, open2, strip, locInfo) {
       var escapeFlag = open2.charAt(3) || open2.charAt(2), escaped = escapeFlag !== "{" && escapeFlag !== "&";
       var decorator = /\*/.test(open2);
       return {
         type: decorator ? "Decorator" : "MustacheStatement",
-        path: path20,
+        path: path21,
         params,
         hash,
         escaped,
@@ -3296,9 +3296,9 @@ var require_compiler = __commonJS({
       },
       DecoratorBlock: function DecoratorBlock(decorator) {
         var program2 = decorator.program && this.compileProgram(decorator.program);
-        var params = this.setupFullMustacheParams(decorator, program2, void 0), path20 = decorator.path;
+        var params = this.setupFullMustacheParams(decorator, program2, void 0), path21 = decorator.path;
         this.useDecorators = true;
-        this.opcode("registerDecorator", params.length, path20.original);
+        this.opcode("registerDecorator", params.length, path21.original);
       },
       PartialStatement: function PartialStatement(partial) {
         this.usePartial = true;
@@ -3362,46 +3362,46 @@ var require_compiler = __commonJS({
         }
       },
       ambiguousSexpr: function ambiguousSexpr(sexpr, program2, inverse) {
-        var path20 = sexpr.path, name = path20.parts[0], isBlock = program2 != null || inverse != null;
-        this.opcode("getContext", path20.depth);
+        var path21 = sexpr.path, name = path21.parts[0], isBlock = program2 != null || inverse != null;
+        this.opcode("getContext", path21.depth);
         this.opcode("pushProgram", program2);
         this.opcode("pushProgram", inverse);
-        path20.strict = true;
-        this.accept(path20);
+        path21.strict = true;
+        this.accept(path21);
         this.opcode("invokeAmbiguous", name, isBlock);
       },
       simpleSexpr: function simpleSexpr(sexpr) {
-        var path20 = sexpr.path;
-        path20.strict = true;
-        this.accept(path20);
+        var path21 = sexpr.path;
+        path21.strict = true;
+        this.accept(path21);
         this.opcode("resolvePossibleLambda");
       },
       helperSexpr: function helperSexpr(sexpr, program2, inverse) {
-        var params = this.setupFullMustacheParams(sexpr, program2, inverse), path20 = sexpr.path, name = path20.parts[0];
+        var params = this.setupFullMustacheParams(sexpr, program2, inverse), path21 = sexpr.path, name = path21.parts[0];
         if (this.options.knownHelpers[name]) {
           this.opcode("invokeKnownHelper", params.length, name);
         } else if (this.options.knownHelpersOnly) {
           throw new _exception2["default"]("You specified knownHelpersOnly, but used the unknown helper " + name, sexpr);
         } else {
-          path20.strict = true;
-          path20.falsy = true;
-          this.accept(path20);
-          this.opcode("invokeHelper", params.length, path20.original, _ast2["default"].helpers.simpleId(path20));
+          path21.strict = true;
+          path21.falsy = true;
+          this.accept(path21);
+          this.opcode("invokeHelper", params.length, path21.original, _ast2["default"].helpers.simpleId(path21));
         }
       },
-      PathExpression: function PathExpression(path20) {
-        this.addDepth(path20.depth);
-        this.opcode("getContext", path20.depth);
-        var name = path20.parts[0], scoped = _ast2["default"].helpers.scopedId(path20), blockParamId = !path20.depth && !scoped && this.blockParamIndex(name);
+      PathExpression: function PathExpression(path21) {
+        this.addDepth(path21.depth);
+        this.opcode("getContext", path21.depth);
+        var name = path21.parts[0], scoped = _ast2["default"].helpers.scopedId(path21), blockParamId = !path21.depth && !scoped && this.blockParamIndex(name);
         if (blockParamId) {
-          this.opcode("lookupBlockParam", blockParamId, path20.parts);
+          this.opcode("lookupBlockParam", blockParamId, path21.parts);
         } else if (!name) {
           this.opcode("pushContext");
-        } else if (path20.data) {
+        } else if (path21.data) {
           this.options.data = true;
-          this.opcode("lookupData", path20.depth, path20.parts, path20.strict);
+          this.opcode("lookupData", path21.depth, path21.parts, path21.strict);
         } else {
-          this.opcode("lookupOnContext", path20.parts, path20.falsy, path20.strict, scoped);
+          this.opcode("lookupOnContext", path21.parts, path21.falsy, path21.strict, scoped);
         }
       },
       StringLiteral: function StringLiteral(string) {
@@ -3751,16 +3751,16 @@ var require_util = __commonJS({
     }
     exports.urlGenerate = urlGenerate;
     function normalize(aPath) {
-      var path20 = aPath;
+      var path21 = aPath;
       var url = urlParse(aPath);
       if (url) {
         if (!url.path) {
           return aPath;
         }
-        path20 = url.path;
+        path21 = url.path;
       }
-      var isAbsolute = exports.isAbsolute(path20);
-      var parts = path20.split(/\/+/);
+      var isAbsolute = exports.isAbsolute(path21);
+      var parts = path21.split(/\/+/);
       for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {
         part = parts[i];
         if (part === ".") {
@@ -3777,15 +3777,15 @@ var require_util = __commonJS({
           }
         }
       }
-      path20 = parts.join("/");
-      if (path20 === "") {
-        path20 = isAbsolute ? "/" : ".";
+      path21 = parts.join("/");
+      if (path21 === "") {
+        path21 = isAbsolute ? "/" : ".";
       }
       if (url) {
-        url.path = path20;
+        url.path = path21;
         return urlGenerate(url);
       }
-      return path20;
+      return path21;
     }
     exports.normalize = normalize;
     function join(aRoot, aPath) {
@@ -6568,8 +6568,8 @@ var require_printer = __commonJS({
       return this.accept(sexpr.path) + " " + params + hash;
     };
     PrintVisitor.prototype.PathExpression = function(id) {
-      var path20 = id.parts.join("/");
-      return (id.data ? "@" : "") + "PATH:" + path20;
+      var path21 = id.parts.join("/");
+      return (id.data ? "@" : "") + "PATH:" + path21;
     };
     PrintVisitor.prototype.StringLiteral = function(string) {
       return '"' + string.value + '"';
@@ -7219,7 +7219,7 @@ function getErrorMessage(error) {
 
 // src/program.ts
 import { randomUUID as randomUUID7 } from "node:crypto";
-import path19 from "node:path";
+import path20 from "node:path";
 import { setTimeout as sleep2 } from "node:timers/promises";
 
 // ../common/dist/src/stdlib/json.util.js
@@ -12394,8 +12394,8 @@ var RENDER_TEMPLATE_ERROR_REASON_CATALOG = defineErrorReasonCatalog()([
 ]);
 var storeReferencePathPattern = String.raw`store(?:\.[$A-Z_a-z][\w$]*)*`;
 var storeReferenceMarkdownLinkTemplateRegex = new RegExp(String.raw`(?<open>\{\{\{?)\s*\[(?<path>${storeReferencePathPattern})\]\(\s*<?https?:\/\/\k<path>>?\s*\)\s*(?<close>\}\}\}?)`, "gu");
-function normalizeAutomationStoreTemplateLinkMatch([_match, open2, path20]) {
-  return open2 === "{{{" ? `{{{${path20}}}}` : `{{${path20}}}`;
+function normalizeAutomationStoreTemplateLinkMatch([_match, open2, path21]) {
+  return open2 === "{{{" ? `{{{${path21}}}}` : `{{${path21}}}`;
 }
 function normalizeAutomationStoreTemplateLinks(template) {
   return template.replaceAll(storeReferenceMarkdownLinkTemplateRegex, (...args) => normalizeAutomationStoreTemplateLinkMatch(args));
@@ -12883,16 +12883,19 @@ var clickAndConfirmAgentcoreInputSchema = clickAndConfirmMarkerInputSchema.exten
 var clickAndConfirmComparisonSchema = clickAndConfirmAgentcoreInputSchema.extend({
   [COMMON_PARAMETERS_KEY]: DEFAULT_COMMON_PARAMETERS
 });
+var textEntryModeSchema = z10.enum(["direct", "keyboard"]).describe("Internal clickFill input strategy. Copy textEntryMode from the command instructions; use direct when unspecified. Never infer the mode from the field or text. Browser keyboard mode enters text character by character. Desktop retains its configured input method for either mode.");
 var clickFillMarkerInputSchema = z10.object({
   marker: markerSchema("The marker of the input field to fill."),
-  text: z10.string().describe("The text to fill the marker with")
+  text: z10.string().describe("The text to fill the marker with"),
+  textEntryMode: textEntryModeSchema.default("direct")
 });
 var clickFillCoordinateInputSchema = z10.object({
   coordinates: coordinateSchema({
     xDescription: "The x coordinate of the element to fill.",
     yDescription: "The y coordinate of the element to fill."
   }),
-  text: z10.string().describe("The text to fill the field with")
+  text: z10.string().describe("The text to fill the field with"),
+  textEntryMode: textEntryModeSchema.default("direct")
 });
 var clickFillComparisonSchema = z10.union([
   clickFillMarkerInputSchema.extend({
@@ -13881,18 +13884,18 @@ var specialCommands = {
 // ../common/dist/src/utils/automation-store-path.util.js
 var AUTOMATION_STORE_ROOT_PATH = "store";
 var relativeStorePathRegex = /^[$A-Z_a-z][\w$]*(?:\.[$A-Z_a-z][\w$]*)*$/u;
-function normalizeStoreMutationPath(path20) {
-  const trimmedPath = path20.trim();
+function normalizeStoreMutationPath(path21) {
+  const trimmedPath = path21.trim();
   const rootPrefix = `${AUTOMATION_STORE_ROOT_PATH}.`;
   const relativePath = trimmedPath.startsWith(rootPrefix) ? trimmedPath.slice(rootPrefix.length) : trimmedPath;
   if (!relativeStorePathRegex.test(relativePath)) {
     return Err({
       type: "invalid-automation-store-path",
-      path: path20,
+      path: path21,
       categories: ["customer_usage"],
       statusCode: 400,
       nonRetryable: true,
-      message: `Automation store path "${path20}" is invalid.`,
+      message: `Automation store path "${path21}" is invalid.`,
       suggestedAction: "Use a dot path relative to the automation store, such as patient.name or provider.clinic."
     });
   }
@@ -13905,16 +13908,16 @@ function findAutomationStorePathOverlap(paths) {
     ...new Set(paths.map(getCanonicalAutomationStoreMutationPath))
   ].toSorted((left, right) => (left === AUTOMATION_STORE_ROOT_PATH ? 0 : left.split(".").length) - (right === AUTOMATION_STORE_ROOT_PATH ? 0 : right.split(".").length));
   for (const [index, ancestorPath] of canonicalPaths.entries()) {
-    const descendantPath = canonicalPaths.slice(index + 1).find((path20) => ancestorPath === AUTOMATION_STORE_ROOT_PATH || path20.startsWith(`${ancestorPath}.`));
+    const descendantPath = canonicalPaths.slice(index + 1).find((path21) => ancestorPath === AUTOMATION_STORE_ROOT_PATH || path21.startsWith(`${ancestorPath}.`));
     if (descendantPath !== void 0) {
       return { ancestorPath, descendantPath };
     }
   }
   return void 0;
 }
-function getCanonicalAutomationStoreMutationPath(path20) {
-  const normalizedPath = normalizeStoreMutationPath(path20);
-  return normalizedPath._tag === "Ok" ? normalizedPath.value : path20.trim();
+function getCanonicalAutomationStoreMutationPath(path21) {
+  const normalizedPath = normalizeStoreMutationPath(path21);
+  return normalizedPath._tag === "Ok" ? normalizedPath.value : path21.trim();
 }
 
 // ../common/dist/src/constants/tool-declarations.js
@@ -14093,9 +14096,9 @@ var baseToolDeclarations = {
           path: []
         });
       }
-      const canonicalUpdatePaths = updates.map(({ path: path20 }) => getCanonicalAutomationStoreMutationPath(path20));
+      const canonicalUpdatePaths = updates.map(({ path: path21 }) => getCanonicalAutomationStoreMutationPath(path21));
       const canonicalClearPathSet = new Set(clears.map(getCanonicalAutomationStoreMutationPath));
-      const conflictedUpdatePath = canonicalUpdatePaths.find((path20) => canonicalClearPathSet.has(path20));
+      const conflictedUpdatePath = canonicalUpdatePaths.find((path21) => canonicalClearPathSet.has(path21));
       if (conflictedUpdatePath !== void 0) {
         context.addIssue({
           code: "custom",
@@ -14628,9 +14631,9 @@ var magicalApiKeyPermissionPresets = [
 import { z as z25 } from "zod";
 
 // ../common/dist/src/utils/agent-knowledge-base-assets.util.js
-function getIsKnowledgeBaseAssetPathAllowed(path20) {
-  const pathSegments = path20.split("/");
-  if (path20.length === 0 || pathSegments.some((segment) => segment.length === 0)) {
+function getIsKnowledgeBaseAssetPathAllowed(path21) {
+  const pathSegments = path21.split("/");
+  if (path21.length === 0 || pathSegments.some((segment) => segment.length === 0)) {
     return false;
   }
   const isTopLevelAssetPath = pathSegments[0] === "assets";
@@ -14685,29 +14688,29 @@ var ApiEmbeddedFileContentTypes = [
 ];
 var API_EMBEDDED_FILE_PATH_PATTERN = /^(?:\[\*\]|[A-Za-z_$][\w$-]*)(?:\[\*\]|\.[A-Za-z_$][\w$-]*)*$/u;
 var API_EMBEDDED_FILE_PATH_SEGMENT_PATTERN = /\[\*\]|[A-Za-z_$][\w$-]*/gu;
-function parseApiEmbeddedFilePath(path20) {
-  if (!API_EMBEDDED_FILE_PATH_PATTERN.test(path20)) {
+function parseApiEmbeddedFilePath(path21) {
+  if (!API_EMBEDDED_FILE_PATH_PATTERN.test(path21)) {
     return void 0;
   }
-  return [...path20.matchAll(API_EMBEDDED_FILE_PATH_SEGMENT_PATTERN)].map(([segment]) => segment === "[*]" ? { type: "arrayWildcard" } : { key: segment, type: "property" });
+  return [...path21.matchAll(API_EMBEDDED_FILE_PATH_SEGMENT_PATTERN)].map(([segment]) => segment === "[*]" ? { type: "arrayWildcard" } : { key: segment, type: "property" });
 }
 var apiAgentEmbeddedFileSchema = z17.object({
-  path: z17.string().trim().min(1, "Embedded file path is required.").refine((path20) => parseApiEmbeddedFilePath(path20) !== void 0, {
+  path: z17.string().trim().min(1, "Embedded file path is required.").refine((path21) => parseApiEmbeddedFilePath(path21) !== void 0, {
     message: "Embedded file path must use object properties and [*] array wildcards."
   }).describe("Path to a Base64 value relative to the projected API response. Supports object properties and [*] array wildcards."),
   contentType: z17.enum(ApiEmbeddedFileContentTypes).describe("File type of the decoded Base64 value. Use auto to detect PDF, PNG, or JPEG from each file\u2019s contents. Unrecognized files are skipped.")
 }).strict();
 var apiAgentEmbeddedFilesSchema = z17.array(apiAgentEmbeddedFileSchema).superRefine((embeddedFiles, context) => {
   const paths = /* @__PURE__ */ new Set();
-  for (const [index, { path: path20 }] of embeddedFiles.entries()) {
-    if (paths.has(path20)) {
+  for (const [index, { path: path21 }] of embeddedFiles.entries()) {
+    if (paths.has(path21)) {
       context.addIssue({
         code: z17.ZodIssueCode.custom,
-        message: `Embedded file path "${path20}" can only be configured once.`,
+        message: `Embedded file path "${path21}" can only be configured once.`,
         path: [index, "path"]
       });
     }
-    paths.add(path20);
+    paths.add(path21);
   }
 }).describe("Base64 values to decode, upload as permanent files, and replace with file references in the projected API response.");
 
@@ -14717,13 +14720,13 @@ var API_REQUEST_FILE_PATH_PATTERN = /^[A-Za-z_$][\w$-]*(?:\.[A-Za-z_$][\w$-]*)*$
 var API_REQUEST_BASE64_FILE_HELPER_PATTERN = /^\s*\{\{\s*base64File\s+(?<sourceInput>[^{}\s]+)\s*\}\}\s*$/u;
 var API_REQUEST_BASE64_FILE_HELPER_USAGE_PATTERN = /\{\{\s*base64File\b/u;
 var API_REQUEST_BASE64_FILE_HELPER_EXAMPLE = "{{base64File fileInput}}";
-function parseApiRequestFilePath(path20) {
-  if (!API_REQUEST_FILE_PATH_PATTERN.test(path20)) {
+function parseApiRequestFilePath(path21) {
+  if (!API_REQUEST_FILE_PATH_PATTERN.test(path21)) {
     return void 0;
   }
-  return path20.split(".");
+  return path21.split(".");
 }
-function inspectApiRequestBase64FileHelperValue({ path: path20, value }) {
+function inspectApiRequestBase64FileHelperValue({ path: path21, value }) {
   const match = API_REQUEST_BASE64_FILE_HELPER_PATTERN.exec(value);
   if (match === null) {
     return API_REQUEST_BASE64_FILE_HELPER_USAGE_PATTERN.test(value) ? {
@@ -14731,7 +14734,7 @@ function inspectApiRequestBase64FileHelperValue({ path: path20, value }) {
       issues: [
         {
           message: `Use ${API_REQUEST_BASE64_FILE_HELPER_EXAMPLE} as the entire JSON field value.`,
-          path: path20
+          path: path21
         }
       ]
     } : { helpers: [], issues: [] };
@@ -14743,24 +14746,24 @@ function inspectApiRequestBase64FileHelperValue({ path: path20, value }) {
       issues: [
         {
           message: "Base64 file helper input must use an object property path.",
-          path: path20
+          path: path21
         }
       ]
     };
   }
   return {
-    helpers: [{ destinationPath: path20, sourceInput }],
+    helpers: [{ destinationPath: path21, sourceInput }],
     issues: []
   };
 }
-function inspectApiRequestBase64FileHelpers(body, path20 = []) {
+function inspectApiRequestBase64FileHelpers(body, path21 = []) {
   if (typeof body === "string") {
-    return inspectApiRequestBase64FileHelperValue({ path: path20, value: body });
+    return inspectApiRequestBase64FileHelperValue({ path: path21, value: body });
   }
   if (Array.isArray(body)) {
     return body.reduce((inspection, value, index) => {
       const nestedInspection = inspectApiRequestBase64FileHelpers(value, [
-        ...path20,
+        ...path21,
         index
       ]);
       return {
@@ -14774,7 +14777,7 @@ function inspectApiRequestBase64FileHelpers(body, path20 = []) {
   }
   return Object.entries(body).reduce((inspection, [key, value]) => {
     const nestedInspection = inspectApiRequestBase64FileHelpers(value, [
-      ...path20,
+      ...path21,
       key
     ]);
     return {
@@ -14818,10 +14821,10 @@ function validateApiRequestBase64FileHelpers({ body, bodyType, context, supports
   }
 }
 var apiAgentRequestFileEncodingSchema = z18.object({
-  sourceInput: z18.string().trim().min(1, "File input is required.").refine((path20) => parseApiRequestFilePath(path20) !== void 0, {
+  sourceInput: z18.string().trim().min(1, "File input is required.").refine((path21) => parseApiRequestFilePath(path21) !== void 0, {
     message: "File input must use an object property path."
   }).describe("API Agent input containing the file reference to encode."),
-  destinationPath: z18.string().trim().min(1, "Request field is required.").refine((path20) => parseApiRequestFilePath(path20) !== void 0, {
+  destinationPath: z18.string().trim().min(1, "Request field is required.").refine((path21) => parseApiRequestFilePath(path21) !== void 0, {
     message: "Request field must use an object property path."
   }).describe("JSON request body path where the encoded value is inserted."),
   encoding: z18.literal("base64").describe("Encoding applied to the source file before insertion.")
@@ -15179,30 +15182,30 @@ function hasControlCharacter(value) {
   }
   return false;
 }
-function isNormalizedRepoPath(path20) {
-  if (path20 === "/") {
+function isNormalizedRepoPath(path21) {
+  if (path21 === "/") {
     return true;
   }
-  if (path20.length === 0 || path20.startsWith("/") || path20.startsWith("\\") || path20.includes("\\") || hasControlCharacter(path20) || windowsAbsolutePathPattern.test(path20)) {
+  if (path21.length === 0 || path21.startsWith("/") || path21.startsWith("\\") || path21.includes("\\") || hasControlCharacter(path21) || windowsAbsolutePathPattern.test(path21)) {
     return false;
   }
-  return path20.split("/").every((segment) => segment.length > 0 && segment !== "." && segment !== ".." && segment !== ".git");
+  return path21.split("/").every((segment) => segment.length > 0 && segment !== "." && segment !== ".." && segment !== ".git");
 }
-function normalizeRepoPath(path20) {
-  if (path20 === "/") {
-    return path20;
+function normalizeRepoPath(path21) {
+  if (path21 === "/") {
+    return path21;
   }
-  return path20.replaceAll(/\/+$/gu, "");
+  return path21.replaceAll(/\/+$/gu, "");
 }
 var skillPathPattern = /^(?:skills\/.+|automations\/[^/]+\/skills\/.+|automations\/[^/]+\/agents\/[^/]+\/skills\/.+)$/u;
 var skillRootPathPattern = /^(?:skills\/[^/]+|automations\/[^/]+\/skills\/[^/]+|automations\/[^/]+\/agents\/[^/]+\/skills\/[^/]+)$/u;
 var repoPathSchema = z25.string().min(1).transform(normalizeRepoPath).refine(isNormalizedRepoPath, {
   message: "Path must be a normalized repository-relative path."
 });
-var registeredSkillPathSchema = repoPathSchema.refine((path20) => skillPathPattern.test(path20), {
+var registeredSkillPathSchema = repoPathSchema.refine((path21) => skillPathPattern.test(path21), {
   message: "Skill paths must be under root, automation, or automation-agent skills."
 });
-var registeredSkillRootPathSchema = registeredSkillPathSchema.refine((path20) => skillRootPathPattern.test(path20) && !path20.endsWith("/SKILL.md"), {
+var registeredSkillRootPathSchema = registeredSkillPathSchema.refine((path21) => skillRootPathPattern.test(path21) && !path21.endsWith("/SKILL.md"), {
   message: "Registered skill paths must identify a skill root directory."
 });
 var knowledgeBasePluginPermissionSchema = z25.object({
@@ -15838,13 +15841,13 @@ function getMentionedStandardCommand(instructions) {
   const normalizedInstructions = instructions.toLowerCase();
   return STANDARD_COMMAND_NAMES.find((commandName) => normalizedInstructions.includes(commandName.toLowerCase())) ?? null;
 }
-function assertCustomInstructionsCommand({ commands, path: path20 }) {
-  const customCommands = commands.flatMap((command, commandIndex) => command["commandName"] === "custom" ? [{ command, path: `${path20}[${commandIndex.toString()}]` }] : []);
+function assertCustomInstructionsCommand({ commands, path: path21 }) {
+  const customCommands = commands.flatMap((command, commandIndex) => command["commandName"] === "custom" ? [{ command, path: `${path21}[${commandIndex.toString()}]` }] : []);
   if (customCommands.length === 0) {
     return;
   }
   if (customCommands.length > MAX_CUSTOM_COMMAND_COUNT) {
-    throw createInvalidValueError(`${path20} contains ${customCommands.length.toString()} custom commands. Use at most ${MAX_CUSTOM_COMMAND_COUNT.toString()} short custom commands per agent. Split policy, decision, outreach, and multi-step work into catalog commands or child agents instead.`);
+    throw createInvalidValueError(`${path21} contains ${customCommands.length.toString()} custom commands. Use at most ${MAX_CUSTOM_COMMAND_COUNT.toString()} short custom commands per agent. Split policy, decision, outreach, and multi-step work into catalog commands or child agents instead.`);
   }
   for (const customCommand of customCommands) {
     const instructions = getCustomInstructions(customCommand.command);
@@ -16073,8 +16076,8 @@ function createOperationSpec(spec) {
 }
 
 // ../mcp-registry/src/operation-specs.ts
-var AUTOMATION_BRANCH_NAME_PATTERN = /^[\da-z]+(?:-[\da-z]+)*$/u;
-var AUTOMATION_BRANCH_NAME_MESSAGE = 'Branch name must use lowercase letters or numbers separated by single dashes (for example, "release-2").';
+var AUTOMATION_BRANCH_NAME_PATTERN = /^[\da-z]+(?:[-/][\da-z]+)*$/u;
+var AUTOMATION_BRANCH_NAME_MESSAGE = 'Branch name must use lowercase letters or numbers separated by single dashes or slashes (for example, "otto/branch-fix").';
 function stringOption({
   clientOnly = false,
   description,
@@ -16226,7 +16229,7 @@ function isRecord3(value) {
 function validateCustomInstructionsCommands({
   commands,
   ctx,
-  path: path20
+  path: path21
 }) {
   if (!Array.isArray(commands)) {
     return;
@@ -16234,14 +16237,14 @@ function validateCustomInstructionsCommands({
   const validationResult = fromThrowable(() => {
     assertCustomInstructionsCommand({
       commands: commands.map((command) => isRecord3(command) ? command : {}),
-      path: path20.join(".").replaceAll(/\.(?<index>\d+)/gu, "[$<index>]")
+      path: path21.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: path20
+      path: path21
     });
   }
 }
@@ -16597,6 +16600,38 @@ var automationRunsCliOptions = [
   })
 ];
 var operationSpecs = [
+  createOperationSpec({
+    operationName: "Classify",
+    apiKeyAccess: apiKeyAccessPolicies.baseline,
+    kind: "query",
+    inputSchema: z28.object({ input: jsonObjectSchema }),
+    cli: {
+      name: "classify",
+      path: ["classify"],
+      description: "Answer typed noul, choice, and score questions about supplied context.",
+      resultKey: "classify",
+      options: [
+        stringOption({
+          clientOnly: true,
+          description: "TypeSafe-shaped request object as inline JSON.",
+          flagName: "input-json",
+          inputKey: "inputJson",
+          valueHint: "JSON"
+        }),
+        stringOption({
+          clientOnly: true,
+          description: "Path to request JSON, or - to read stdin.",
+          flagName: "input-file",
+          inputKey: "inputFile"
+        })
+      ]
+    },
+    mcp: { exposed: false, fileName: "classify.graphql" },
+    document: `# Answer typed questions about caller-supplied context
+query Classify($input: JSON!) {
+  classify(input: $input)
+}`
+  }),
   createOperationSpec({
     operationName: "KnowledgeFiles",
     apiKeyAccess: apiKeyAccessPolicies.knowledgeRead,
@@ -18100,7 +18135,7 @@ query ListAutomationBranches($automationId: ID!) {
         stringOption({
           inputKey: "name",
           flagName: "name",
-          description: 'Lowercase branch name with single dashes between words or numbers (for example, "release-2").',
+          description: 'Lowercase branch name with single dashes or slashes between words or numbers (for example, "otto/branch-fix").',
           required: true
         }),
         stringOption({
@@ -19314,7 +19349,7 @@ mutation skills_apply_patch(
     cli: {
       name: "create-automation",
       path: ["automations", "create"],
-      description: "Create a draft automation.",
+      description: "Create a draft automation. Inspect publishChecks and repair blocking failures before completing the task.",
       resultKey: "createAutomation",
       options: [
         jsonOption({
@@ -19327,10 +19362,12 @@ mutation skills_apply_patch(
     },
     mcp: { fileName: "createAutomation.graphql" },
     document: `# Mutation to create a draft automation with optional initial values
+# Draft saves are allowed. Inspect publishChecks, repair blocking failures, and save again before completing the task. Unknown means checks must be retried.
 # Returns flat fields only for MCP tool simplicity
 mutation CreateAutomation($input: CreateAutomationInput!) {
   createAutomation(input: $input) {
     id
+    publishChecks
     name
     organizationId
     createdAt
@@ -19912,7 +19949,7 @@ mutation ValidateAutomationPatchReadiness(
       branchContext: "optional",
       name: "apply-automation-patch",
       path: ["workbench", "patch", "apply"],
-      description: "Apply semantic workbench patch operations through the versioned save path.",
+      description: "Apply semantic workbench patch operations through the versioned save path. Inspect publishChecks and repair blocking failures before completing the task.",
       resultKey: "applyAutomationPatch",
       options: [
         stringOption({
@@ -19936,6 +19973,7 @@ mutation ValidateAutomationPatchReadiness(
     },
     mcp: { fileName: "applyAutomationPatch.graphql" },
     document: `# Apply semantic automation patch operations through the versioned save path.
+# Inspect publishChecks after saving. Repair blocking failures and save again before completing the task; retry unknown checks.
 mutation ApplyAutomationPatch(
   $draftAutomationId: ID!
   $branchId: ID
@@ -19952,6 +19990,7 @@ mutation ApplyAutomationPatch(
     branchId
     headVersionId
     applied
+    publishChecks
     updateInput
     before {
       name
@@ -20037,7 +20076,7 @@ mutation ApplyAutomationPatch(
       branchContext: "optional",
       name: "update-automation-by-id",
       path: ["automations", "update"],
-      description: "Update an automation.",
+      description: "Update an automation. Inspect publishChecks and repair blocking failures before completing the task. Changing agent types is not supported. Do not attempt type changes or replacement workarounds.",
       resultKey: "updateAutomation",
       options: [
         stringOption({
@@ -20060,13 +20099,14 @@ mutation ApplyAutomationPatch(
 # If this mutation returns a draft-automation-version-conflict, discard the generated update, refetch the automation and agents, inspect what changed, then regenerate the update on top of the latest version.
 # config.storeSchema remains additive. Use removeStoreSchemaPaths to delete named properties (and combine it with config.storeSchema for an atomic rename), or replaceStoreSchema for an exact replacement. replaceStoreSchema cannot be combined with either of those fields.
 # Destructive Store schema changes are rejected when the final agent set still references a removed property. Rewrite those agent references in the same update or leave the property in place.
-# Returns only id and lastSavedAt for MCP tool simplicity
+# Draft saves are allowed. Inspect publishChecks, repair blocking failures, and save again before completing the task. Unknown means checks must be retried.
 mutation UpdateAutomationById($id: ID!, $branchId: ID, $input: UpdateAutomationInput!) {
   updateAutomation(id: $id, branchId: $branchId, input: $input) {
     id
     branchId
     headVersionId
     lastSavedAt
+    publishChecks
   }
 }`
   }),
@@ -21427,18 +21467,18 @@ async function downloadAuthenticatedFileFromApi({
   organizationId,
   outputPath,
   overwrite = false,
-  path: path20,
+  path: path21,
   resolveApiBaseUrl,
   timeoutMs
 }) {
-  if (!path20.startsWith("/") || path20.startsWith("//")) {
+  if (!path21.startsWith("/") || path21.startsWith("//")) {
     throw new CliError(
       "Authenticated file download path must be relative to the configured Magical API."
     );
   }
   const normalizedApiBaseUrl = trimTrailingSlash(await resolveApiBaseUrl());
   const apiBaseResult = safeUrlConstructor(`${normalizedApiBaseUrl}/`);
-  const urlResult = safeUrlConstructor(`${normalizedApiBaseUrl}${path20}`);
+  const urlResult = safeUrlConstructor(`${normalizedApiBaseUrl}${path21}`);
   if (isErr(apiBaseResult) || isErr(urlResult) || urlResult.value.origin !== apiBaseResult.value.origin || !urlResult.value.pathname.startsWith(apiBaseResult.value.pathname)) {
     throw new CliError(
       "Authenticated file download path must stay within the configured Magical API."
@@ -21535,16 +21575,16 @@ function buildPathwayRegressionAgentVersionPath({
   leafPath,
   runsPerPath
 }) {
-  const path20 = `/pathway-regression/automation-versions/${encodeURIComponent(
+  const path21 = `/pathway-regression/automation-versions/${encodeURIComponent(
     automationVersionId
   )}/agent-versions/${encodeURIComponent(agentVersionId)}/${leafPath}`;
   if (runsPerPath === void 0) {
-    return path20;
+    return path21;
   }
   const queryParams = new URLSearchParams({
     runsPerPath: String(runsPerPath)
   });
-  return `${path20}?${queryParams.toString()}`;
+  return `${path21}?${queryParams.toString()}`;
 }
 function applyAuthenticationHeaders({
   accessToken,
@@ -21580,11 +21620,11 @@ function createFetchJson({
     accessToken,
     impersonatedOrganizationId,
     allowOttoAuthorization,
-    path: path20,
+    path: path21,
     init,
     organizationId
   }) {
-    const url = `${trimTrailingSlash(await resolveApiBaseUrl())}${path20}`;
+    const url = `${trimTrailingSlash(await resolveApiBaseUrl())}${path21}`;
     const usesWorkOSApiKey = isWorkOSApiKey(accessToken);
     const headers = new Headers(init?.headers);
     applyAuthenticationHeaders({
@@ -21784,7 +21824,7 @@ function createMagicalApiClient({
       organizationId,
       outputPath,
       overwrite = false,
-      path: path20,
+      path: path21,
       timeoutMs
     }) {
       await downloadAuthenticatedFileFromApi({
@@ -21797,7 +21837,7 @@ function createMagicalApiClient({
         ...maxSizeBytes === void 0 ? {} : { maxSizeBytes },
         outputPath,
         overwrite,
-        path: path20,
+        path: path21,
         resolveApiBaseUrl,
         ...timeoutMs === void 0 ? {} : { timeoutMs }
       });
@@ -27227,6 +27267,140 @@ async function pollCaptureRecording({
   });
 }
 
+// src/classify-command.ts
+import { readFile as readFile3 } from "node:fs/promises";
+import path8 from "node:path";
+import { z as z36 } from "zod";
+var classifyRequestSchema = z36.object({
+  model: z36.string().refine((model) => model.trim().length > 0, "Model must not be empty.").optional(),
+  questions: z36.record(z36.string(), z36.unknown()).refine(
+    (questions) => Object.keys(questions).length > 0,
+    "Questions must contain at least one named question."
+  ),
+  state: z36.unknown()
+}).passthrough().refine((input) => Object.hasOwn(input, "state"), {
+  message: "Classify input must include state.",
+  path: ["state"]
+});
+var CLASSIFY_OPERATION_NAME = "Classify";
+var CLASSIFY_HELP_TEXT = `
+Classify input:
+  Pass exactly one of --input-json, --input-file <path>, or --input-file - for stdin.
+  All named questions share the supplied state and are answered independently.
+  The backend defaults to jev-latest; set model in the request to select an explicit supported model.
+  Noul values are probabilities, choice answers retain option probabilities, and scores may be fractional.
+  Supply text or JSON evidence only; URLs and named files are not fetched. Output is always the full JSON response.
+
+Examples:
+  mgcl classify --input-file request.json
+  mgcl classify --input-json '{"state":"Refund requested","questions":{"refund":{"type":"noul","instructions":"Is a refund requested?"}}}'
+  cat request.json | mgcl classify --input-file -`;
+async function readStdin() {
+  process.stdin.setEncoding("utf8");
+  let contents = "";
+  for await (const chunk of process.stdin) {
+    if (typeof chunk !== "string") {
+      throw new CliError("Classify stdin must be UTF-8 text.");
+    }
+    contents += chunk;
+  }
+  return contents;
+}
+async function readInputFile({
+  inputFile,
+  runtime
+}) {
+  if (inputFile === "-") {
+    return await (runtime.readStdin ?? readStdin)().catch(
+      (error) => {
+        throw new CliError("Failed to read classify input from stdin.", {
+          cause: error
+        });
+      }
+    );
+  }
+  const inputPath = path8.resolve(
+    runtime.workingDirectory ?? process.cwd(),
+    inputFile
+  );
+  return await readFile3(inputPath, "utf8").catch((error) => {
+    throw new CliError(`Failed to read classify input file "${inputPath}".`, {
+      cause: error
+    });
+  });
+}
+async function resolveClassifyVariables({
+  inputFile,
+  inputJson,
+  runtime = {}
+}) {
+  const hasInputFile = inputFile !== void 0;
+  const hasInputJson = inputJson !== void 0;
+  if (Number(hasInputFile) + Number(hasInputJson) !== 1) {
+    throw new CliError(
+      "Pass exactly one of --input-json or --input-file for classify input."
+    );
+  }
+  let input = inputJson;
+  if (hasInputFile) {
+    if (typeof inputFile !== "string" || inputFile.length === 0) {
+      throw new CliError("--input-file must name a JSON file or - for stdin.");
+    }
+    const contents = await readInputFile({ inputFile, runtime });
+    const parsedJson = safeJsonParseWithoutLogging(contents);
+    if (isErr(parsedJson)) {
+      const source = inputFile === "-" ? "stdin" : `file "${inputFile}"`;
+      throw new CliError(`Classify input from ${source} must be valid JSON.`, {
+        cause: parsedJson.error
+      });
+    }
+    input = parsedJson.value;
+  } else if (typeof inputJson === "string") {
+    const parsedJson = safeJsonParseWithoutLogging(inputJson);
+    if (isErr(parsedJson)) {
+      throw new CliError(
+        "Classify input from --input-json must be valid JSON.",
+        {
+          cause: parsedJson.error
+        }
+      );
+    }
+    input = parsedJson.value;
+  }
+  const parsedInput = classifyRequestSchema.safeParse(input);
+  if (!parsedInput.success) {
+    throw new CliError(
+      parsedInput.error.issues[0]?.message ?? "Classify input must be a JSON object containing state and questions."
+    );
+  }
+  return { input: parsedInput.data };
+}
+async function resolveClassifyOperationVariables({
+  defaultVariables,
+  operationName,
+  options,
+  runtime,
+  workingDirectory
+}) {
+  if (operationName !== CLASSIFY_OPERATION_NAME) {
+    return defaultVariables;
+  }
+  return await resolveClassifyVariables({
+    inputFile: options["inputFile"],
+    inputJson: options["inputJson"],
+    runtime: {
+      ...runtime,
+      workingDirectory: runtime?.workingDirectory ?? workingDirectory
+    }
+  });
+}
+function configureClassifyHelp(command, operationName) {
+  if (operationName === CLASSIFY_OPERATION_NAME) {
+    command.addHelpText("after", CLASSIFY_HELP_TEXT);
+    command.setOptionValueWithSource("json", true, "default");
+  }
+}
+
 // src/cli-io.ts
 function createConsoleIo() {
   return {
@@ -27243,53 +27417,53 @@ function createConsoleIo() {
 
 // src/eval-commands.ts
 import { randomUUID as randomUUID4 } from "node:crypto";
-import { access as access2, readFile as readFile3 } from "node:fs/promises";
-import path8 from "node:path";
+import { access as access2, readFile as readFile4 } from "node:fs/promises";
+import path9 from "node:path";
 import { createInterface } from "node:readline/promises";
-import { z as z36 } from "zod";
+import { z as z37 } from "zod";
 var MAX_AWAIT_REQUEST_MS = 6e4;
 var MIN_AWAIT_REQUEST_MS = 1e3;
 var EXPORT_POLL_INTERVAL_MS = 1e3;
-var evalRunStatusSchema2 = z36.enum([
+var evalRunStatusSchema2 = z37.enum([
   "QUEUED",
   "RUNNING",
   "COMPLETE",
   "FAILED",
   "CANCELLED"
 ]);
-var awaitResultSchema = z36.object({
-  elapsedMs: z36.number().nonnegative(),
-  evalRun: z36.object({
-    id: z36.string().min(1),
+var awaitResultSchema = z37.object({
+  elapsedMs: z37.number().nonnegative(),
+  evalRun: z37.object({
+    id: z37.string().min(1),
     status: evalRunStatusSchema2
   }).passthrough(),
-  pollCount: z36.number().int().nonnegative(),
-  reachedTerminal: z36.boolean()
+  pollCount: z37.number().int().nonnegative(),
+  reachedTerminal: z37.boolean()
 }).passthrough();
-var planResultSchema = z36.object({ trialCount: z36.number().int().nonnegative() }).passthrough();
-var startResultSchema = z36.object({
-  evalRunId: z36.string().min(1),
-  idempotencyKey: z36.string().min(1),
-  workflowId: z36.string().min(1),
-  workflowRunId: z36.string().min(1)
+var planResultSchema = z37.object({ trialCount: z37.number().int().nonnegative() }).passthrough();
+var startResultSchema = z37.object({
+  evalRunId: z37.string().min(1),
+  idempotencyKey: z37.string().min(1),
+  workflowId: z37.string().min(1),
+  workflowRunId: z37.string().min(1)
 }).passthrough();
-var exportResultSchema = z36.object({
-  downloadUrl: z36.string().min(1).nullable().optional(),
-  evalRunId: z36.string().min(1),
-  exportId: z36.string().min(1),
-  status: z36.enum(["QUEUED", "RUNNING", "COMPLETE", "FAILED"])
+var exportResultSchema = z37.object({
+  downloadUrl: z37.string().min(1).nullable().optional(),
+  evalRunId: z37.string().min(1),
+  exportId: z37.string().min(1),
+  status: z37.enum(["QUEUED", "RUNNING", "COMPLETE", "FAILED"])
 }).passthrough();
-var inputOptionsSchema = z36.object({
-  inputFile: z36.string().min(1).optional(),
-  inputJson: z36.unknown().optional()
+var inputOptionsSchema = z37.object({
+  inputFile: z37.string().min(1).optional(),
+  inputJson: z37.unknown().optional()
 });
 var commonRunOptionsSchema = inputOptionsSchema.extend({
-  description: z36.string().min(1).optional(),
-  maxConcurrency: z36.number().int().positive().optional(),
-  name: z36.string().min(1).optional(),
-  repeatCount: z36.number().int().positive().optional(),
-  slug: z36.string().min(1),
-  tags: z36.array(z36.string().min(1)).optional()
+  description: z37.string().min(1).optional(),
+  maxConcurrency: z37.number().int().positive().optional(),
+  name: z37.string().min(1).optional(),
+  repeatCount: z37.number().int().positive().optional(),
+  slug: z37.string().min(1),
+  tags: z37.array(z37.string().min(1)).optional()
 });
 function parseApiResult(value, schema, label) {
   const parsedResult = schema.safeParse(value);
@@ -27302,8 +27476,8 @@ async function parseInputFile({
   inputFile,
   workingDirectory
 }) {
-  const inputPath = path8.resolve(workingDirectory, inputFile);
-  const contents = await readFile3(inputPath, "utf8").catch(
+  const inputPath = path9.resolve(workingDirectory, inputFile);
+  const contents = await readFile4(inputPath, "utf8").catch(
     (error) => {
       throw new CliError(`Failed to read eval input file "${inputPath}".`, {
         cause: error
@@ -27331,7 +27505,7 @@ async function resolveEvalInput({
     );
   }
   const input = inputFile === void 0 ? inputJson : await parseInputFile({ inputFile, workingDirectory });
-  const parsedInput = z36.record(z36.string(), z36.unknown()).safeParse(input);
+  const parsedInput = z37.record(z37.string(), z37.unknown()).safeParse(input);
   if (!parsedInput.success) {
     throw new CliError("Eval input must be a JSON object.");
   }
@@ -27368,7 +27542,7 @@ function parseDurationMs(value) {
   );
   const amount = Number(match?.groups?.["amount"]);
   const multiplierByUnit = { h: 36e5, m: 6e4, ms: 1, s: 1e3 };
-  const parsedUnit = z36.enum(["h", "m", "ms", "s"]).safeParse(match?.groups?.["unit"]?.toLowerCase());
+  const parsedUnit = z37.enum(["h", "m", "ms", "s"]).safeParse(match?.groups?.["unit"]?.toLowerCase());
   const durationMs = parsedUnit.success ? amount * multiplierByUnit[parsedUnit.data] : Number.NaN;
   if (!Number.isSafeInteger(durationMs) || durationMs < MIN_AWAIT_REQUEST_MS) {
     throw new CliError(
@@ -27577,10 +27751,10 @@ async function executeStartRegisteredEvalRun({
   workingDirectory
 }) {
   const parsedOptions = commonRunOptionsSchema.extend({
-    confirmTrials: z36.number().int().positive().optional(),
-    idempotencyKey: z36.string().trim().min(1).optional(),
-    json: z36.boolean().optional(),
-    wait: z36.boolean().optional()
+    confirmTrials: z37.number().int().positive().optional(),
+    idempotencyKey: z37.string().trim().min(1).optional(),
+    json: z37.boolean().optional(),
+    wait: z37.boolean().optional()
   }).parse(options);
   const input = await resolveEvalInputFromOptions({
     ...parsedOptions,
@@ -27640,7 +27814,7 @@ async function executeAwaitEvalRun({
   options,
   runtime
 }) {
-  const parsedOptions = z36.object({ id: z36.string().min(1), timeout: z36.string().optional() }).parse(options);
+  const parsedOptions = z37.object({ id: z37.string().min(1), timeout: z37.string().optional() }).parse(options);
   return await awaitEvalRun({
     evalRunId: parsedOptions.id,
     executeOperation,
@@ -27659,13 +27833,13 @@ async function executeRequestEvalRunExport({
   runtime,
   workingDirectory
 }) {
-  const parsedOptions = z36.object({
-    force: z36.boolean().optional(),
-    id: z36.string().min(1),
-    output: z36.string().min(1),
-    wait: z36.boolean().optional()
+  const parsedOptions = z37.object({
+    force: z37.boolean().optional(),
+    id: z37.string().min(1),
+    output: z37.string().min(1),
+    wait: z37.boolean().optional()
   }).parse(options);
-  const outputPath = path8.resolve(workingDirectory, parsedOptions.output);
+  const outputPath = path9.resolve(workingDirectory, parsedOptions.output);
   const force = parsedOptions.force === true;
   const shouldWait = parsedOptions.wait === true;
   if (shouldWait) {
@@ -27731,28 +27905,28 @@ async function executeEvalCliOperation({
 // src/file-upload-commands.ts
 import { createReadStream as createReadStream2 } from "node:fs";
 import { stat as stat2 } from "node:fs/promises";
-import path9 from "node:path";
+import path10 from "node:path";
 import mimeTypes from "mime-types";
-import { z as z37 } from "zod";
-var fileUploadIntentSchema = z37.object({
-  file: z37.object({
-    checksum: z37.object({
-      algorithm: z37.literal("CRC32"),
-      value: z37.string().min(1)
+import { z as z38 } from "zod";
+var fileUploadIntentSchema = z38.object({
+  file: z38.object({
+    checksum: z38.object({
+      algorithm: z38.literal("CRC32"),
+      value: z38.string().min(1)
     }),
-    key: z37.string().startsWith("s3://"),
-    mimeType: z37.string().min(1),
-    name: z37.string().min(1),
-    sizeBytes: z37.number().int().nonnegative()
+    key: z38.string().startsWith("s3://"),
+    mimeType: z38.string().min(1),
+    name: z38.string().min(1),
+    sizeBytes: z38.number().int().nonnegative()
   }),
-  upload: z37.object({
-    headers: z37.record(z37.string(), z37.string()),
-    method: z37.literal("PUT"),
-    url: z37.url()
+  upload: z38.object({
+    headers: z38.record(z38.string(), z38.string()),
+    method: z38.literal("PUT"),
+    url: z38.url()
   })
 });
 async function prepareFileUpload(inputPath, workingDirectory) {
-  const filePath = path9.resolve(workingDirectory, inputPath);
+  const filePath = path10.resolve(workingDirectory, inputPath);
   const fileStats = await stat2(filePath).catch((error) => {
     throw new CliError(`Failed to inspect upload file "${filePath}".`, {
       cause: error
@@ -27791,7 +27965,7 @@ async function prepareFileUpload(inputPath, workingDirectory) {
     variables: {
       checksum: encodeS3Crc32Checksum(checksum),
       mimeType: mimeTypes.lookup(filePath) || "application/octet-stream",
-      name: path9.basename(filePath),
+      name: path10.basename(filePath),
       sizeBytes: fileStats.size
     }
   };
@@ -27837,20 +28011,20 @@ async function handleFileUploadCliOperation(apiClient, intent, prepared) {
 }
 
 // src/iteration-media-commands.ts
-import path12 from "node:path";
-import { z as z40 } from "zod";
+import path13 from "node:path";
+import { z as z41 } from "zod";
 
 // src/file-commands.ts
-import path10 from "node:path";
-import { z as z38 } from "zod";
-var fileAssetAccessSchema = z38.object({
-  status: z38.enum([
+import path11 from "node:path";
+import { z as z39 } from "zod";
+var fileAssetAccessSchema = z39.object({
+  status: z39.enum([
     "AVAILABLE",
     "INVALID_KEY",
     "NOT_FOUND",
     "URL_UNAVAILABLE"
   ]),
-  url: z38.string().url().nullable()
+  url: z39.string().url().nullable()
 }).superRefine((value, ctx) => {
   if (value.status === "AVAILABLE" && value.url === null) {
     ctx.addIssue({
@@ -27860,13 +28034,13 @@ var fileAssetAccessSchema = z38.object({
     });
   }
 });
-var fileCommandOptionsSchema = z38.object({
-  download: z38.string().min(1).optional(),
-  force: z38.boolean().optional(),
-  key: z38.string().min(1)
+var fileCommandOptionsSchema = z39.object({
+  download: z39.string().min(1).optional(),
+  force: z39.boolean().optional(),
+  key: z39.string().min(1)
 });
 function sanitizeDownloadFileName(fileName, fallback = "magical-file.bin") {
-  const sanitizedFileName = path10.basename(fileName).replaceAll(/[^\p{L}\p{N}._-]/gu, "_").slice(0, 160);
+  const sanitizedFileName = path11.basename(fileName).replaceAll(/[^\p{L}\p{N}._-]/gu, "_").slice(0, 160);
   return sanitizedFileName && sanitizedFileName !== "." && sanitizedFileName !== ".." ? sanitizedFileName : fallback;
 }
 function getSafeFileName(fileKey) {
@@ -27888,7 +28062,7 @@ async function downloadFileToLocalPath({
       "File download is not configured for this CLI instance."
     );
   }
-  const outputPath = path10.resolve(
+  const outputPath = path11.resolve(
     runtime.workingDirectory,
     destination ?? sanitizeDownloadFileName(fallbackFileName)
   );
@@ -27934,19 +28108,19 @@ async function handleFileCliOperation({
 }
 
 // src/repository-file-commands.ts
-import path11 from "node:path";
-import { z as z39 } from "zod";
+import path12 from "node:path";
+import { z as z40 } from "zod";
 var repositoryFileOperationNames = /* @__PURE__ */ new Set(["KnowledgeFile", "MemoryFile"]);
-var repositoryFileOptionsSchema = z39.object({
-  download: z39.string().min(1),
-  force: z39.boolean().optional(),
-  key: z39.string().min(1)
+var repositoryFileOptionsSchema = z40.object({
+  download: z40.string().min(1),
+  force: z40.boolean().optional(),
+  key: z40.string().min(1)
 });
-var repositoryFileAccessSchema = z39.object({
-  commit: z39.string().regex(/^[\da-f]{40}$/u).nullable(),
-  path: z39.string().min(1).nullable(),
-  status: z39.enum(["AVAILABLE", "INVALID_KEY", "NOT_FOUND", "UNAVAILABLE"]),
-  url: z39.url().nullable()
+var repositoryFileAccessSchema = z40.object({
+  commit: z40.string().regex(/^[\da-f]{40}$/u).nullable(),
+  path: z40.string().min(1).nullable(),
+  status: z40.enum(["AVAILABLE", "INVALID_KEY", "NOT_FOUND", "UNAVAILABLE"]),
+  url: z40.url().nullable()
 }).superRefine((value, ctx) => {
   if (value.status === "AVAILABLE" && (value.url === null || value.path === null || value.commit === null)) {
     ctx.addIssue({
@@ -27983,7 +28157,7 @@ async function handleRepositoryFileCliOperation({
   }
   const outputPath = await downloadFileToLocalPath({
     destination: parsedOptions.download,
-    fallbackFileName: path11.basename(repositoryPath),
+    fallbackFileName: path12.basename(repositoryPath),
     force: parsedOptions.force === true,
     runtime,
     url
@@ -27998,14 +28172,14 @@ async function handleRepositoryFileCliOperation({
 }
 
 // src/iteration-media-commands.ts
-var iterationMediaOptionsSchema = z40.object({
-  download: z40.string().min(1),
-  force: z40.boolean().optional(),
-  iterationId: z40.uuid(),
-  mediaId: z40.uuid()
+var iterationMediaOptionsSchema = z41.object({
+  download: z41.string().min(1),
+  force: z41.boolean().optional(),
+  iterationId: z41.uuid(),
+  mediaId: z41.uuid()
 });
-var iterationMediaAccessSchema = z40.object({
-  downloadPath: z40.string().min(1)
+var iterationMediaAccessSchema = z41.object({
+  downloadPath: z41.string().min(1)
 });
 async function handleIterationMediaCliOperation({
   accessToken,
@@ -28036,7 +28210,7 @@ async function handleIterationMediaCliOperation({
       "Authenticated file download is not configured for this CLI instance."
     );
   }
-  const outputPath = path12.resolve(workingDirectory, parsedOptions.download);
+  const outputPath = path13.resolve(workingDirectory, parsedOptions.download);
   const downloadResult = await fromThrowable(async () => {
     await downloadAuthenticatedFile({
       accessToken,
@@ -28150,16 +28324,16 @@ import { randomUUID as randomUUID5 } from "node:crypto";
 import { createReadStream as createReadStream3, createWriteStream as createWriteStream2 } from "node:fs";
 import { link as link3, mkdir as mkdir3, mkdtemp, rm as rm3 } from "node:fs/promises";
 import os2 from "node:os";
-import path14 from "node:path";
+import path15 from "node:path";
 import { pipeline as pipeline2 } from "node:stream/promises";
 import { Command as Command3, InvalidArgumentError, Option as Option3 } from "commander";
 
 // src/network-recording-parser.ts
 import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
-import path13 from "node:path";
+import path14 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { z as z41 } from "zod";
+import { z as z42 } from "zod";
 var NETWORK_RECORDING_ARCHIVE_MAX_BYTES = 256 * 1024 * 1024;
 var NETWORK_RECORDING_MAX_FLOWS = 2e4;
 var NETWORK_RECORDING_MAX_ENCODED_BODY_BYTES = 32 * 1024 * 1024;
@@ -28171,57 +28345,57 @@ var DEFAULT_MAX_EXCHANGES = 100;
 var MAX_EXCHANGES = 1e3;
 var MAX_HELPER_OUTPUT_BYTES = 1024 * 1024;
 var PYTHON_ENVIRONMENT_VARIABLE = "MGCL_MITMPROXY_PYTHON";
-var archiveIdentitySchema = z41.object({
-  sha256: z41.string().regex(/^[0-9a-f]{64}$/u),
-  sizeBytes: z41.number().int().nonnegative()
-});
-var bodyMetadataSchema = z41.object({
-  state: z41.enum(["PRESENT", "EMPTY", "MISSING"]),
-  encodedSizeBytes: z41.number().int().nonnegative().nullable()
-});
-var exchangeSchema = z41.object({
-  exchange: z41.string().regex(/^mitm-v1:[0-9a-f]{64}:[0-9]+$/u),
-  index: z41.number().int().nonnegative(),
-  method: z41.string().min(1),
-  origin: z41.string().min(1),
-  timestamp: z41.string().nullable(),
-  response: z41.object({
-    status: z41.number().int(),
-    contentType: z41.string().nullable(),
+var archiveIdentitySchema = z42.object({
+  sha256: z42.string().regex(/^[0-9a-f]{64}$/u),
+  sizeBytes: z42.number().int().nonnegative()
+});
+var bodyMetadataSchema = z42.object({
+  state: z42.enum(["PRESENT", "EMPTY", "MISSING"]),
+  encodedSizeBytes: z42.number().int().nonnegative().nullable()
+});
+var exchangeSchema = z42.object({
+  exchange: z42.string().regex(/^mitm-v1:[0-9a-f]{64}:[0-9]+$/u),
+  index: z42.number().int().nonnegative(),
+  method: z42.string().min(1),
+  origin: z42.string().min(1),
+  timestamp: z42.string().nullable(),
+  response: z42.object({
+    status: z42.number().int(),
+    contentType: z42.string().nullable(),
     body: bodyMetadataSchema
   }).nullable()
 });
-var inspectionResultSchema = z41.object({
+var inspectionResultSchema = z42.object({
   archive: archiveIdentitySchema,
-  exchanges: z41.array(exchangeSchema),
-  scan: z41.object({
-    scannedFlowCount: z41.number().int().nonnegative(),
-    returnedExchangeCount: z41.number().int().nonnegative(),
-    complete: z41.boolean(),
-    resultLimit: z41.number().int().positive(),
-    flowLimit: z41.number().int().positive(),
-    truncationReason: z41.enum(["RESULT_LIMIT", "FLOW_LIMIT"]).nullable()
+  exchanges: z42.array(exchangeSchema),
+  scan: z42.object({
+    scannedFlowCount: z42.number().int().nonnegative(),
+    returnedExchangeCount: z42.number().int().nonnegative(),
+    complete: z42.boolean(),
+    resultLimit: z42.number().int().positive(),
+    flowLimit: z42.number().int().positive(),
+    truncationReason: z42.enum(["RESULT_LIMIT", "FLOW_LIMIT"]).nullable()
   })
 });
-var extractionResultSchema = z41.object({
+var extractionResultSchema = z42.object({
   archive: archiveIdentitySchema,
-  exchange: z41.string().regex(/^mitm-v1:[0-9a-f]{64}:[0-9]+$/u),
-  index: z41.number().int().nonnegative(),
-  response: z41.object({
-    contentType: z41.string().nullable(),
-    sourceContentEncoding: z41.string().nullable(),
-    representation: z41.literal("decoded-entity-body"),
-    encodedSizeBytes: z41.number().int().nonnegative(),
-    sizeBytes: z41.number().int().nonnegative(),
-    sha256: z41.string().regex(/^[0-9a-f]{64}$/u)
+  exchange: z42.string().regex(/^mitm-v1:[0-9a-f]{64}:[0-9]+$/u),
+  index: z42.number().int().nonnegative(),
+  response: z42.object({
+    contentType: z42.string().nullable(),
+    sourceContentEncoding: z42.string().nullable(),
+    representation: z42.literal("decoded-entity-body"),
+    encodedSizeBytes: z42.number().int().nonnegative(),
+    sizeBytes: z42.number().int().nonnegative(),
+    sha256: z42.string().regex(/^[0-9a-f]{64}$/u)
   }),
-  outputPath: z41.string().min(1)
+  outputPath: z42.string().min(1)
 });
-var helperResponseSchema = z41.union([
-  z41.object({ ok: z41.literal(true), result: z41.unknown() }),
-  z41.object({
-    ok: z41.literal(false),
-    error: z41.object({ code: z41.string().min(1), message: z41.string().min(1) })
+var helperResponseSchema = z42.union([
+  z42.object({ ok: z42.literal(true), result: z42.unknown() }),
+  z42.object({
+    ok: z42.literal(false),
+    error: z42.object({ code: z42.string().min(1), message: z42.string().min(1) })
   })
 ]);
 var NetworkRecordingParserError = class extends CliError {
@@ -28233,12 +28407,12 @@ var NetworkRecordingParserError = class extends CliError {
   }
 };
 function helperPath() {
-  const moduleDirectory = path13.dirname(fileURLToPath2(import.meta.url));
-  const bundledPath = path13.resolve(
+  const moduleDirectory = path14.dirname(fileURLToPath2(import.meta.url));
+  const bundledPath = path14.resolve(
     moduleDirectory,
     "network-recording-archive.py"
   );
-  return existsSync(bundledPath) ? bundledPath : path13.resolve(moduleDirectory, "../scripts/network-recording-archive.py");
+  return existsSync(bundledPath) ? bundledPath : path14.resolve(moduleDirectory, "../scripts/network-recording-archive.py");
 }
 function pythonCandidates() {
   const configuredPython = getRuntimeEnvironment()[PYTHON_ENVIRONMENT_VARIABLE];
@@ -28552,11 +28726,11 @@ async function installPrivateOutput({
   destination,
   source
 }) {
-  const outputPath = path14.resolve(destination);
-  await mkdir3(path14.dirname(outputPath), { recursive: true });
-  const temporaryPath = path14.join(
-    path14.dirname(outputPath),
-    `.${path14.basename(outputPath)}.${randomUUID5()}.tmp`
+  const outputPath = path15.resolve(destination);
+  await mkdir3(path15.dirname(outputPath), { recursive: true });
+  const temporaryPath = path15.join(
+    path15.dirname(outputPath),
+    `.${path15.basename(outputPath)}.${randomUUID5()}.tmp`
   );
   await pipeline2(
     createReadStream3(source),
@@ -28586,9 +28760,9 @@ async function withPrivateArchive({
   recording
 }) {
   const temporaryDirectory = await mkdtemp(
-    path14.join(os2.tmpdir(), "mgcl-network-recording-")
+    path15.join(os2.tmpdir(), "mgcl-network-recording-")
   );
-  const archivePath = path14.join(temporaryDirectory, "recording.mitm");
+  const archivePath = path15.join(temporaryDirectory, "recording.mitm");
   try {
     await downloadRecording({
       dependencies,
@@ -28636,7 +28810,7 @@ function addNetworkRecordingCommands({
     });
     const result = getSafeMetadata(recording.metadata);
     if (options.output) {
-      const outputPath = path14.resolve(
+      const outputPath = path15.resolve(
         dependencies.workingDirectory ?? process.cwd(),
         options.output
       );
@@ -28717,11 +28891,11 @@ function addNetworkRecordingCommands({
           {
             archivePath,
             exchange: options.exchange,
-            outputPath: path14.join(temporaryDirectory, "response-body")
+            outputPath: path15.join(temporaryDirectory, "response-body")
           }
         );
         const outputPath = await installPrivateOutput({
-          destination: path14.resolve(
+          destination: path15.resolve(
             dependencies.workingDirectory ?? process.cwd(),
             options.output
           ),
@@ -29065,29 +29239,29 @@ ${formatExamples("Examples", [
 
 // src/run-evidence-commands.ts
 import { Option as Option5 } from "commander";
-import { z as z42 } from "zod";
+import { z as z43 } from "zod";
 var ITERATION_PAGE_SIZE = 100;
 var MAX_SCANNED_ITERATIONS = 1e4;
-var automationRunSchema = z42.object({
-  id: z42.string().min(1),
-  input: z42.unknown().nullable()
+var automationRunSchema = z43.object({
+  id: z43.string().min(1),
+  input: z43.unknown().nullable()
 }).passthrough();
-var agentRunSchema = z42.object({
-  id: z42.string().min(1),
-  input: z42.unknown().nullable(),
-  parentAgentRunId: z42.string().nullable()
+var agentRunSchema = z43.object({
+  id: z43.string().min(1),
+  input: z43.unknown().nullable(),
+  parentAgentRunId: z43.string().nullable()
 }).passthrough();
-var memorySchema = z42.object({
-  id: z42.string().min(1),
-  sequence: z42.number().int(),
-  type: z42.string(),
-  value: z42.unknown()
+var memorySchema = z43.object({
+  id: z43.string().min(1),
+  sequence: z43.number().int(),
+  type: z43.string(),
+  value: z43.unknown()
 }).passthrough();
-var iterationSchema = z42.object({
-  agentRunId: z42.string().min(1),
-  id: z42.string().min(1),
-  memories: z42.array(memorySchema),
-  sequence: z42.number().int()
+var iterationSchema = z43.object({
+  agentRunId: z43.string().min(1),
+  id: z43.string().min(1),
+  memories: z43.array(memorySchema),
+  sequence: z43.number().int()
 }).passthrough();
 var latestIterationSchema = iterationSchema.nullable();
 var GET_AUTOMATION_RUN_FILE_INPUT_DOCUMENT = `
@@ -29242,21 +29416,21 @@ function collectIterationOccurrences(iteration) {
 function formatRunFiles(result) {
   const parsed = parseOperationResult(
     result,
-    z42.object({
-      automationRunId: z42.string(),
-      files: z42.array(
-        z42.object({
-          agentRunId: z42.string().nullable(),
-          fieldPath: z42.string(),
-          iterationId: z42.string().nullable(),
-          key: z42.string(),
-          role: z42.string(),
-          source: z42.string(),
-          toolName: z42.string().nullable()
+    z43.object({
+      automationRunId: z43.string(),
+      files: z43.array(
+        z43.object({
+          agentRunId: z43.string().nullable(),
+          fieldPath: z43.string(),
+          iterationId: z43.string().nullable(),
+          key: z43.string(),
+          role: z43.string(),
+          source: z43.string(),
+          toolName: z43.string().nullable()
         })
       ),
-      scannedIterationCount: z42.number(),
-      truncated: z42.boolean()
+      scannedIterationCount: z43.number(),
+      truncated: z43.boolean()
     }),
     "Run file inventory"
   );
@@ -29281,9 +29455,9 @@ function formatRunFiles(result) {
 function formatAgentRunOutput(result) {
   const parsed = parseOperationResult(
     result,
-    z42.object({
-      output: z42.unknown(),
-      status: z42.enum(["AVAILABLE", "NOT_FOUND"])
+    z43.object({
+      output: z43.unknown(),
+      status: z43.enum(["AVAILABLE", "NOT_FOUND"])
     }),
     "Agent run output"
   );
@@ -29342,7 +29516,7 @@ async function handleAutomationRunFiles({
   );
   const agentRuns = parseOperationResult(
     agentRunsResult,
-    z42.array(agentRunSchema),
+    z43.array(agentRunSchema),
     "Automation run agent runs"
   );
   const iterations = [];
@@ -29361,7 +29535,7 @@ async function handleAutomationRunFiles({
     });
     const parsedPage = parseOperationResult(
       pageResult,
-      z42.array(iterationSchema),
+      z43.array(iterationSchema),
       "Automation run iterations"
     );
     iterations.push(...parsedPage);
@@ -29382,7 +29556,7 @@ async function handleAutomationRunFiles({
     });
     truncated = parseOperationResult(
       peekResult,
-      z42.array(iterationSchema),
+      z43.array(iterationSchema),
       "Automation run iterations"
     ).length > 0;
   }
@@ -29515,7 +29689,7 @@ function addRunEvidenceCommands({
 // src/self-update.ts
 import { spawn as spawn3 } from "node:child_process";
 import fs2 from "node:fs";
-import path15 from "node:path";
+import path16 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 var CLI_PACKAGE_NAME = "@getmagical/cli";
 var DEFAULT_CLI_DIST_TAG2 = "latest";
@@ -29526,9 +29700,9 @@ function resolveInstalledPackageRoot({
   packageName
 }) {
   const packagePathSegments = packageName.split("/");
-  let currentPath = path15.dirname(entryFilePath);
+  let currentPath = path16.dirname(entryFilePath);
   for (; ; ) {
-    const currentPathSegments = currentPath.split(path15.sep).filter(Boolean);
+    const currentPathSegments = currentPath.split(path16.sep).filter(Boolean);
     const currentPackageSegments = currentPathSegments.slice(
       -packagePathSegments.length
     );
@@ -29537,7 +29711,7 @@ function resolveInstalledPackageRoot({
     )) {
       return currentPath;
     }
-    const parentPath = path15.dirname(currentPath);
+    const parentPath = path16.dirname(currentPath);
     if (parentPath === currentPath) {
       return null;
     }
@@ -29547,14 +29721,14 @@ function resolveInstalledPackageRoot({
 function resolveInstallPrefixFromPackageRoot(packageRootPath) {
   let currentPath = packageRootPath;
   for (; ; ) {
-    if (path15.basename(currentPath) === "node_modules") {
-      const nodeModulesParentPath = path15.dirname(currentPath);
-      if (path15.basename(nodeModulesParentPath) === "lib") {
-        return path15.dirname(nodeModulesParentPath);
+    if (path16.basename(currentPath) === "node_modules") {
+      const nodeModulesParentPath = path16.dirname(currentPath);
+      if (path16.basename(nodeModulesParentPath) === "lib") {
+        return path16.dirname(nodeModulesParentPath);
       }
       return nodeModulesParentPath;
     }
-    const parentPath = path15.dirname(currentPath);
+    const parentPath = path16.dirname(currentPath);
     if (parentPath === currentPath) {
       return null;
     }
@@ -29571,13 +29745,13 @@ function resolveManagedNpmCommand(installPrefix) {
   if (process.platform === "win32") {
     return null;
   }
-  const managedNodeExecutable = path15.join(
+  const managedNodeExecutable = path16.join(
     installPrefix,
     MANAGED_NODE_SUBPATH,
     "bin",
     "node"
   );
-  const managedNpmCli = path15.join(
+  const managedNpmCli = path16.join(
     installPrefix,
     MANAGED_NODE_SUBPATH,
     "lib",
@@ -29676,15 +29850,15 @@ async function selfUpdateInstalledCli({
 }
 
 // src/settings.ts
-import { mkdir as mkdir4, readFile as readFile4, rm as rm4, writeFile as writeFile2 } from "node:fs/promises";
-import path16 from "node:path";
-import { z as z43 } from "zod";
-var cliSettingsSchema = z43.object({
-  env: z43.object({
-    baseUrl: z43.url().optional(),
-    domain: z43.url().optional(),
-    env: z43.enum(["us", "uk", "stg"]).optional(),
-    workosEnv: z43.string().min(1).optional()
+import { mkdir as mkdir4, readFile as readFile5, rm as rm4, writeFile as writeFile2 } from "node:fs/promises";
+import path17 from "node:path";
+import { z as z44 } from "zod";
+var cliSettingsSchema = z44.object({
+  env: z44.object({
+    baseUrl: z44.url().optional(),
+    domain: z44.url().optional(),
+    env: z44.enum(["us", "uk", "stg"]).optional(),
+    workosEnv: z44.string().min(1).optional()
   }).default({})
 });
 function createEmptyCliSettings() {
@@ -29696,13 +29870,13 @@ function hasCliSettingsOverrides(settings) {
   return Object.values(settings.env).some((value) => value !== void 0);
 }
 function resolveSettingsFilePath(stateFilePath) {
-  return path16.join(path16.dirname(stateFilePath), CLI_SETTINGS_FILE_NAME);
+  return path17.join(path17.dirname(stateFilePath), CLI_SETTINGS_FILE_NAME);
 }
 function createFileSettingsStore(stateFilePath) {
   const settingsFilePath = resolveSettingsFilePath(stateFilePath);
   return {
     async load() {
-      const fileContents = await readFile4(settingsFilePath, "utf8").catch(
+      const fileContents = await readFile5(settingsFilePath, "utf8").catch(
         (error) => {
           if (error instanceof Error && "code" in error && error.code === "ENOENT") {
             return null;
@@ -29732,7 +29906,7 @@ function createFileSettingsStore(stateFilePath) {
         await rm4(settingsFilePath, { force: true });
         return;
       }
-      await mkdir4(path16.dirname(settingsFilePath), { recursive: true });
+      await mkdir4(path17.dirname(settingsFilePath), { recursive: true });
       await writeFile2(
         settingsFilePath,
         `${JSON.stringify(settings, null, 2)}
@@ -29900,15 +30074,15 @@ import {
   lstat as lstat2,
   mkdir as mkdir5,
   mkdtemp as mkdtemp2,
-  readFile as readFile5,
+  readFile as readFile6,
   readdir,
   rename as rename4,
   rm as rm5,
   writeFile as writeFile3
 } from "node:fs/promises";
 import os3 from "node:os";
-import path17 from "node:path";
-import { z as z44 } from "zod";
+import path18 from "node:path";
+import { z as z45 } from "zod";
 var SKILLS_ROOT_PATH = "skills";
 var METADATA_DIRECTORY_NAME = "skill-working-copies";
 var MAX_GIT_OUTPUT_BYTES = 10 * 1024 * 1024;
@@ -29917,40 +30091,40 @@ var FULL_COMMIT_SHA_PATTERN = /^[\dA-Fa-f]{40}$/u;
 var UTF8_ENCODER = new TextEncoder();
 var WINDOWS_RESERVED_PATH_CHARACTER_PATTERN = /[<>:"|?*]/u;
 var WINDOWS_RESERVED_PATH_NAME_PATTERN = /^(?:AUX|CON|NUL|PRN|COM[1-9]|LPT[1-9])(?:\..*)?$/iu;
-var skillBundleSchema = z44.object({
-  files: z44.array(
-    z44.object({
-      content: z44.string(),
-      encoding: z44.literal("base64"),
-      path: z44.string().min(1),
-      size: z44.number().int().nonnegative()
+var skillBundleSchema = z45.object({
+  files: z45.array(
+    z45.object({
+      content: z45.string(),
+      encoding: z45.literal("base64"),
+      path: z45.string().min(1),
+      size: z45.number().int().nonnegative()
     })
   ),
-  path: z44.string().min(1),
-  ref: z44.string().regex(FULL_COMMIT_SHA_PATTERN)
+  path: z45.string().min(1),
+  ref: z45.string().regex(FULL_COMMIT_SHA_PATTERN)
 });
-var skillsApplyPatchResultSchema = z44.object({
-  changedFiles: z44.array(
-    z44.object({ path: z44.string().min(1), status: z44.string().min(1) })
+var skillsApplyPatchResultSchema = z45.object({
+  changedFiles: z45.array(
+    z45.object({ path: z45.string().min(1), status: z45.string().min(1) })
   ),
-  commit: z44.string().regex(FULL_COMMIT_SHA_PATTERN),
-  ok: z44.boolean(),
-  ref: z44.string().min(1)
+  commit: z45.string().regex(FULL_COMMIT_SHA_PATTERN),
+  ok: z45.boolean(),
+  ref: z45.string().min(1)
 }).refine((result) => result.ok, {
   message: "Skills patch result was not successful."
 });
-var workingCopyMetadataSchema = z44.object({
-  version: z44.literal(1),
-  files: z44.array(
-    z44.object({
-      content: z44.string(),
-      path: z44.string().min(1)
+var workingCopyMetadataSchema = z45.object({
+  version: z45.literal(1),
+  files: z45.array(
+    z45.object({
+      content: z45.string(),
+      path: z45.string().min(1)
     })
   ),
-  organizationId: z44.string().min(1),
-  requestedRef: z44.string().min(1).nullable(),
-  skillPath: z44.string().min(1),
-  workingCopyPath: z44.string().min(1)
+  organizationId: z45.string().min(1),
+  requestedRef: z45.string().min(1).nullable(),
+  skillPath: z45.string().min(1),
+  workingCopyPath: z45.string().min(1)
 });
 function hasControlCharacter2(value) {
   return UTF8_ENCODER.encode(value).some((byte) => byte <= 31 || byte === 127);
@@ -29978,12 +30152,12 @@ function normalizeRootSkillPath(skill) {
   return `${SKILLS_ROOT_PATH}/${skillName}`;
 }
 function resolveWorkingCopyPath(workingDirectory, skillPath) {
-  return path17.resolve(workingDirectory, ...skillPath.split("/"));
+  return path18.resolve(workingDirectory, ...skillPath.split("/"));
 }
 function resolveMetadataPath(stateFilePath, workingCopyPath) {
   const key = createHash3("sha256").update(workingCopyPath).digest("hex");
-  return path17.join(
-    path17.dirname(stateFilePath),
+  return path18.join(
+    path18.dirname(stateFilePath),
     METADATA_DIRECTORY_NAME,
     `${key}.json`
   );
@@ -30011,7 +30185,7 @@ function metadataFilesToSnapshot(files) {
   );
 }
 async function loadMetadata(metadataPath) {
-  const fileContents = await readFile5(metadataPath, "utf8").catch(
+  const fileContents = await readFile6(metadataPath, "utf8").catch(
     (error) => {
       if (isMissingFileError3(error)) {
         return null;
@@ -30035,7 +30209,7 @@ async function loadMetadata(metadataPath) {
   return parsed.data;
 }
 async function saveMetadata(metadataPath, metadata) {
-  await mkdir5(path17.dirname(metadataPath), { recursive: true });
+  await mkdir5(path18.dirname(metadataPath), { recursive: true });
   const temporaryPath = `${metadataPath}.${randomUUID6()}.tmp`;
   await writeFile3(temporaryPath, `${JSON.stringify(metadata, null, 2)}
 `, {
@@ -30112,7 +30286,7 @@ async function readDirectorySnapshot({
         const nextSegments = [...segments, entry.name];
         const relativePath = nextSegments.join("/");
         assertSafeRelativeFilePath(relativePath);
-        const filePath = path17.join(currentDirectory, entry.name);
+        const filePath = path18.join(currentDirectory, entry.name);
         if (entry.isDirectory()) {
           return await visit(filePath, nextSegments);
         }
@@ -30121,7 +30295,7 @@ async function readDirectorySnapshot({
             `Skill working copy contains unsupported entry "${filePath}". Only regular files and directories are allowed.`
           );
         }
-        return [[`${skillPath}/${relativePath}`, await readFile5(filePath)]];
+        return [[`${skillPath}/${relativePath}`, await readFile6(filePath)]];
       })
     );
     return nestedEntries.flat();
@@ -30147,8 +30321,8 @@ async function writeSnapshotContents(rootPath, snapshot, prefix) {
     [...snapshot.entries()].map(async ([filePath, content]) => {
       const relativePath = prefix === null ? filePath : filePath.slice(`${prefix}/`.length);
       assertSafeRelativeFilePath(relativePath);
-      const targetPath = path17.join(rootPath, ...relativePath.split("/"));
-      await mkdir5(path17.dirname(targetPath), { recursive: true });
+      const targetPath = path18.join(rootPath, ...relativePath.split("/"));
+      await mkdir5(path18.dirname(targetPath), { recursive: true });
       await writeFile3(targetPath, content);
     })
   );
@@ -30158,11 +30332,11 @@ async function replaceWorkingCopy({
   skillPath,
   workingCopyPath
 }) {
-  const parentPath = path17.dirname(workingCopyPath);
+  const parentPath = path18.dirname(workingCopyPath);
   await mkdir5(parentPath, { recursive: true });
-  const temporaryPath = path17.join(
+  const temporaryPath = path18.join(
     parentPath,
-    `.mgcl-${path17.basename(workingCopyPath)}-${randomUUID6()}.tmp`
+    `.mgcl-${path18.basename(workingCopyPath)}-${randomUUID6()}.tmp`
   );
   const backupPath = `${workingCopyPath}.${randomUUID6()}.bak`;
   await mkdir5(temporaryPath);
@@ -30233,7 +30407,7 @@ async function clearDirectoryExceptGit(directoryPath) {
   const entries = await readdir(directoryPath);
   await Promise.all(
     entries.filter((entry) => entry !== ".git").map(async (entry) => {
-      await rm5(path17.join(directoryPath, entry), {
+      await rm5(path18.join(directoryPath, entry), {
         force: true,
         recursive: true
       });
@@ -30245,7 +30419,7 @@ async function createPatch(before, after) {
     return "";
   }
   const repositoryPath = await mkdtemp2(
-    path17.join(os3.tmpdir(), "mgcl-skills-diff-")
+    path18.join(os3.tmpdir(), "mgcl-skills-diff-")
   );
   const patchResult = await fromThrowable(async () => {
     await runGit(["init", "--quiet"], repositoryPath);
@@ -30567,27 +30741,27 @@ async function pushSkillWorkingCopy({
 }
 
 // src/state.ts
-import { mkdir as mkdir6, readFile as readFile6, rm as rm6, writeFile as writeFile4 } from "node:fs/promises";
-import path18 from "node:path";
-import { z as z45 } from "zod";
-var cliAccountSchema = z45.object({
-  clientId: z45.string().min(1),
-  email: z45.string().nullable(),
-  userId: z45.string().min(1)
+import { mkdir as mkdir6, readFile as readFile7, rm as rm6, writeFile as writeFile4 } from "node:fs/promises";
+import path19 from "node:path";
+import { z as z46 } from "zod";
+var cliAccountSchema = z46.object({
+  clientId: z46.string().min(1),
+  email: z46.string().nullable(),
+  userId: z46.string().min(1)
 });
-var cliOrganizationSchema = z45.object({
-  id: z45.string().min(1),
-  name: z45.string().min(1),
-  primaryDomain: z45.string().nullable().default(null)
+var cliOrganizationSchema = z46.object({
+  id: z46.string().min(1),
+  name: z46.string().min(1),
+  primaryDomain: z46.string().nullable().default(null)
 });
-var cliStateSchema = z45.object({
+var cliStateSchema = z46.object({
   account: cliAccountSchema,
   deploymentTarget: resolvedDeploymentTargetSchema.optional(),
-  defaultOrgId: z45.string().nullable(),
-  lastUsedOrgId: z45.string().nullable(),
-  organizations: z45.array(cliOrganizationSchema)
+  defaultOrgId: z46.string().nullable(),
+  lastUsedOrgId: z46.string().nullable(),
+  organizations: z46.array(cliOrganizationSchema)
 });
-var refreshTokenFileSchema = z45.record(z45.string(), z45.string());
+var refreshTokenFileSchema = z46.record(z46.string(), z46.string());
 function createFileStateStore(stateFilePath) {
   return {
     async clear() {
@@ -30595,7 +30769,7 @@ function createFileStateStore(stateFilePath) {
     },
     async load() {
       try {
-        const fileContents = await readFile6(stateFilePath, "utf8");
+        const fileContents = await readFile7(stateFilePath, "utf8");
         const parsed = cliStateSchema.safeParse(JSON.parse(fileContents));
         if (!parsed.success) {
           throw new CliError("Stored CLI state is invalid.");
@@ -30612,7 +30786,7 @@ function createFileStateStore(stateFilePath) {
       }
     },
     async save(state) {
-      await mkdir6(path18.dirname(stateFilePath), { recursive: true });
+      await mkdir6(path19.dirname(stateFilePath), { recursive: true });
       await writeFile4(stateFilePath, `${JSON.stringify(state, null, 2)}
 `);
     }
@@ -30621,7 +30795,7 @@ function createFileStateStore(stateFilePath) {
 function createFileRefreshTokenStore(refreshTokenFilePath) {
   async function loadRefreshTokens() {
     try {
-      const fileContents = await readFile6(refreshTokenFilePath, "utf8");
+      const fileContents = await readFile7(refreshTokenFilePath, "utf8");
       const parsed = refreshTokenFileSchema.safeParse(JSON.parse(fileContents));
       if (!parsed.success) {
         throw new CliError("Stored refresh tokens are invalid.");
@@ -30640,7 +30814,7 @@ function createFileRefreshTokenStore(refreshTokenFilePath) {
     }
   }
   async function saveRefreshTokens(refreshTokens) {
-    await mkdir6(path18.dirname(refreshTokenFilePath), { recursive: true });
+    await mkdir6(path19.dirname(refreshTokenFilePath), { recursive: true });
     await writeFile4(
       refreshTokenFilePath,
       `${JSON.stringify(refreshTokens, null, 2)}
@@ -30678,37 +30852,37 @@ function buildRefreshTokenKey(account) {
 }
 
 // src/workos-auth.ts
-import { z as z46 } from "zod";
+import { z as z47 } 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 = z46.object({
-  device_code: z46.string().min(1),
-  expires_in: z46.number().int().positive().optional(),
-  interval: z46.number().int().positive().optional(),
-  user_code: z46.string().min(1),
-  verification_uri: z46.url(),
-  verification_uri_complete: z46.url().optional()
-});
-var tokenResponseSchema = z46.object({
-  access_token: z46.string().min(1),
-  expires_in: z46.number().int().positive().optional(),
-  refresh_token: z46.string().min(1),
-  token_type: z46.string().optional()
-});
-var tokenErrorSchema = z46.object({
-  error: z46.string().min(1),
-  error_description: z46.string().optional()
-});
-var accessTokenClaimsSchema = z46.object({
-  exp: z46.number().int().positive().optional(),
-  iss: z46.string().min(1).optional(),
-  org_id: z46.string().min(1).optional(),
-  sid: z46.string().min(1).optional(),
-  sub: z46.string().min(1)
+var deviceAuthorizationSchema = z47.object({
+  device_code: z47.string().min(1),
+  expires_in: z47.number().int().positive().optional(),
+  interval: z47.number().int().positive().optional(),
+  user_code: z47.string().min(1),
+  verification_uri: z47.url(),
+  verification_uri_complete: z47.url().optional()
+});
+var tokenResponseSchema = z47.object({
+  access_token: z47.string().min(1),
+  expires_in: z47.number().int().positive().optional(),
+  refresh_token: z47.string().min(1),
+  token_type: z47.string().optional()
+});
+var tokenErrorSchema = z47.object({
+  error: z47.string().min(1),
+  error_description: z47.string().optional()
+});
+var accessTokenClaimsSchema = z47.object({
+  exp: z47.number().int().positive().optional(),
+  iss: z47.string().min(1).optional(),
+  org_id: z47.string().min(1).optional(),
+  sid: z47.string().min(1).optional(),
+  sub: z47.string().min(1)
 });
 function createWorkosAuthClient({
   fetchFn = fetch,
@@ -31018,13 +31192,17 @@ async function handleOperationCommand(dependencies, operationSpec, commandOption
     commandOptions,
     dependencies.workingDirectory ?? process.cwd()
   );
-  const variables = parseOperationVariables(
-    operationSpec,
-    getFileUploadOperationVariables(
+  const operationVariables = await resolveClassifyOperationVariables({
+    defaultVariables: getFileUploadOperationVariables(
       collectOperationVariableInput(operationSpec, commandOptions),
       preparedUpload
-    )
-  );
+    ),
+    operationName: operationSpec.operationName,
+    options: commandOptions,
+    runtime: dependencies.classifyCommandRuntime,
+    workingDirectory: dependencies.workingDirectory ?? process.cwd()
+  });
+  const variables = parseOperationVariables(operationSpec, operationVariables);
   const apiKeyEnvironment = getApiKeyEnvironment(
     dependencies,
     commandOptions.apiKey
@@ -32004,6 +32182,9 @@ function addRegistryOperationCommand({
   }
   const command = parentCommand.command(leafCommandName);
   configureOperationalCommand(command, dependencies, operationSpec);
+  if (parentCommand === program2) {
+    return;
+  }
   const legacyAliasCommand = program2.command(operationSpec.cli.name, {
     hidden: true
   });
@@ -32028,6 +32209,7 @@ ${formatExamples(
       createOperationHelpExamples(operationSpec)
     )}`
   );
+  configureClassifyHelp(command, operationSpec.operationName);
   for (const optionSpec of operationSpec.cli.options) {
     command.addOption(
       createCliCommanderOption(
@@ -32053,12 +32235,12 @@ function createDefaultDependencies() {
     return resolveDeploymentTarget({ savedEnv: settings.env, selectors });
   };
   const resolveApiBaseUrl = () => deploymentTargetContext.get().apiUrl;
-  const accessTokenFilePath = runtimeConfig.accessTokenFilePath ?? path19.join(
-    path19.dirname(runtimeConfig.stateFilePath),
+  const accessTokenFilePath = runtimeConfig.accessTokenFilePath ?? path20.join(
+    path20.dirname(runtimeConfig.stateFilePath),
     CLI_ACCESS_TOKEN_FILE_NAME
   );
-  const refreshTokenFilePath = runtimeConfig.refreshTokenFilePath ?? path19.join(
-    path19.dirname(runtimeConfig.stateFilePath),
+  const refreshTokenFilePath = runtimeConfig.refreshTokenFilePath ?? path20.join(
+    path20.dirname(runtimeConfig.stateFilePath),
     CLI_REFRESH_TOKEN_FILE_NAME
   );
   const selfUpdateOptions = {
@@ -32076,8 +32258,8 @@ function createDefaultDependencies() {
     io: createConsoleIo(),
     openExternalUrl,
     orgPreferencesStore: createFileOrgPreferencesStore(
-      path19.join(
-        path19.dirname(runtimeConfig.stateFilePath),
+      path20.join(
+        path20.dirname(runtimeConfig.stateFilePath),
         "organization-preferences"
       )
     ),