@doist/automations-cli 1.17.1 → 1.19.0

package/dist/index.js

@@ -7,7 +7,7 @@ import {
   collectSkillStatus,
   getInstaller,
   updateAllInstalledSkills
-} from "./chunk-DTY2LZDU.js";
+} from "./chunk-SABAHP32.js";
 
 // ../../node_modules/ajv/dist/compile/codegen/code.js
 var require_code = __commonJS({
@@ -2868,7 +2868,7 @@ var require_compile = __commonJS({
       }
     };
     exports.SchemaEnv = SchemaEnv;
-    function compileSchema(sch) {
+    function compileSchema2(sch) {
       const _sch = getCompilingSchema.call(this, sch);
       if (_sch)
         return _sch;
@@ -2953,29 +2953,29 @@ var require_compile = __commonJS({
         this._compilations.delete(sch);
       }
     }
-    exports.compileSchema = compileSchema;
-    function resolveRef2(root15, baseId, ref) {
+    exports.compileSchema = compileSchema2;
+    function resolveRef2(root16, baseId, ref) {
       var _a3;
       ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, ref);
-      const schOrFunc = root15.refs[ref];
+      const schOrFunc = root16.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve.call(this, root15, ref);
+      let _sch = resolve.call(this, root16, ref);
       if (_sch === void 0) {
-        const schema = (_a3 = root15.localRefs) === null || _a3 === void 0 ? void 0 : _a3[ref];
+        const schema = (_a3 = root16.localRefs) === null || _a3 === void 0 ? void 0 : _a3[ref];
         const { schemaId } = this.opts;
         if (schema)
-          _sch = new SchemaEnv({ schema, schemaId, root: root15, baseId });
+          _sch = new SchemaEnv({ schema, schemaId, root: root16, baseId });
       }
       if (_sch === void 0)
         return;
-      return root15.refs[ref] = inlineOrCompile.call(this, _sch);
+      return root16.refs[ref] = inlineOrCompile.call(this, _sch);
     }
     exports.resolveRef = resolveRef2;
     function inlineOrCompile(sch) {
       if ((0, resolve_1.inlineRef)(sch.schema, this.opts.inlineRefs))
         return sch.schema;
-      return sch.validate ? sch : compileSchema.call(this, sch);
+      return sch.validate ? sch : compileSchema2.call(this, sch);
     }
     function getCompilingSchema(schEnv) {
       for (const sch of this._compilations) {
@@ -2987,23 +2987,23 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve(root15, ref) {
+    function resolve(root16, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
-      return sch || this.schemas[ref] || resolveSchema.call(this, root15, ref);
+      return sch || this.schemas[ref] || resolveSchema.call(this, root16, ref);
     }
-    function resolveSchema(root15, ref) {
+    function resolveSchema(root16, ref) {
       const p = this.opts.uriResolver.parse(ref);
       const refPath = (0, resolve_1._getFullPath)(this.opts.uriResolver, p);
-      let baseId = (0, resolve_1.getFullPath)(this.opts.uriResolver, root15.baseId, void 0);
-      if (Object.keys(root15.schema).length > 0 && refPath === baseId) {
-        return getJsonPointer.call(this, p, root15);
+      let baseId = (0, resolve_1.getFullPath)(this.opts.uriResolver, root16.baseId, void 0);
+      if (Object.keys(root16.schema).length > 0 && refPath === baseId) {
+        return getJsonPointer.call(this, p, root16);
       }
       const id = (0, resolve_1.normalizeId)(refPath);
       const schOrRef = this.refs[id] || this.schemas[id];
       if (typeof schOrRef == "string") {
-        const sch = resolveSchema.call(this, root15, schOrRef);
+        const sch = resolveSchema.call(this, root16, schOrRef);
         if (typeof (sch === null || sch === void 0 ? void 0 : sch.schema) !== "object")
           return;
         return getJsonPointer.call(this, p, sch);
@@ -3011,14 +3011,14 @@ var require_compile = __commonJS({
       if (typeof (schOrRef === null || schOrRef === void 0 ? void 0 : schOrRef.schema) !== "object")
         return;
       if (!schOrRef.validate)
-        compileSchema.call(this, schOrRef);
+        compileSchema2.call(this, schOrRef);
       if (id === (0, resolve_1.normalizeId)(ref)) {
         const { schema } = schOrRef;
         const { schemaId } = this.opts;
         const schId = schema[schemaId];
         if (schId)
           baseId = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schId);
-        return new SchemaEnv({ schema, schemaId, root: root15, baseId });
+        return new SchemaEnv({ schema, schemaId, root: root16, baseId });
       }
       return getJsonPointer.call(this, p, schOrRef);
     }
@@ -3030,7 +3030,7 @@ var require_compile = __commonJS({
       "dependencies",
       "definitions"
     ]);
-    function getJsonPointer(parsedRef, { baseId, schema, root: root15 }) {
+    function getJsonPointer(parsedRef, { baseId, schema, root: root16 }) {
       var _a3;
       if (((_a3 = parsedRef.fragment) === null || _a3 === void 0 ? void 0 : _a3[0]) !== "/")
         return;
@@ -3049,10 +3049,10 @@ var require_compile = __commonJS({
       let env;
       if (typeof schema != "boolean" && schema.$ref && !(0, util_1.schemaHasRulesButRef)(schema, this.RULES)) {
         const $ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schema.$ref);
-        env = resolveSchema.call(this, root15, $ref);
+        env = resolveSchema.call(this, root16, $ref);
       }
       const { schemaId } = this.opts;
-      env = env || new SchemaEnv({ schema, schemaId, root: root15, baseId });
+      env = env || new SchemaEnv({ schema, schemaId, root: root16, baseId });
       if (env.schema !== env.root.schema)
         return env;
       return void 0;
@@ -4033,7 +4033,7 @@ var require_core = __commonJS({
         uriResolver
       };
     }
-    var Ajv = class {
+    var Ajv2 = class {
       constructor(opts = {}) {
         this.schemas = {};
         this.refs = {};
@@ -4207,8 +4207,8 @@ var require_core = __commonJS({
           keyRef = sch;
         if (sch === void 0) {
           const { schemaId } = this.opts;
-          const root15 = new compile_1.SchemaEnv({ schema: {}, schemaId });
-          sch = compile_1.resolveSchema.call(this, root15, keyRef);
+          const root16 = new compile_1.SchemaEnv({ schema: {}, schemaId });
+          sch = compile_1.resolveSchema.call(this, root16, keyRef);
           if (!sch)
             return;
           this.refs[keyRef] = sch;
@@ -4317,7 +4317,7 @@ var require_core = __commonJS({
       errorsText(errors = this.errors, { separator = ", ", dataVar = "data" } = {}) {
         if (!errors || errors.length === 0)
           return "No errors";
-        return errors.map((e) => `${dataVar}${e.instancePath} ${e.message}`).reduce((text, msg) => text + separator + msg);
+        return errors.map((e) => `${dataVar}${e.instancePath} ${e.message}`).reduce((text2, msg) => text2 + separator + msg);
       }
       $dataMetaSchema(metaSchema, keywordsJsonPointers) {
         const rules = this.RULES.all;
@@ -4403,9 +4403,9 @@ var require_core = __commonJS({
         }
       }
     };
-    Ajv.ValidationError = validation_error_1.default;
-    Ajv.MissingRefError = ref_error_1.default;
-    exports.default = Ajv;
+    Ajv2.ValidationError = validation_error_1.default;
+    Ajv2.MissingRefError = ref_error_1.default;
+    exports.default = Ajv2;
     function checkOptions(checkOpts, options, msg, log = "error") {
       for (const key in checkOpts) {
         const opt = key;
@@ -4569,20 +4569,20 @@ var require_ref = __commonJS({
       code(cxt) {
         const { gen, schema: $ref, it } = cxt;
         const { baseId, schemaEnv: env, validateName, opts, self } = it;
-        const { root: root15 } = env;
-        if (($ref === "#" || $ref === "#/") && baseId === root15.baseId)
+        const { root: root16 } = env;
+        if (($ref === "#" || $ref === "#/") && baseId === root16.baseId)
           return callRootRef();
-        const schOrEnv = compile_1.resolveRef.call(self, root15, baseId, $ref);
+        const schOrEnv = compile_1.resolveRef.call(self, root16, baseId, $ref);
         if (schOrEnv === void 0)
           throw new ref_error_1.default(it.opts.uriResolver, baseId, $ref);
         if (schOrEnv instanceof compile_1.SchemaEnv)
           return callValidate(schOrEnv);
         return inlineRefSchema(schOrEnv);
         function callRootRef() {
-          if (env === root15)
+          if (env === root16)
             return callRef(cxt, validateName, env, env.$async);
-          const rootName = gen.scopeValue("root", { ref: root15 });
-          return callRef(cxt, (0, codegen_1._)`${rootName}.validate`, root15, root15.$async);
+          const rootName = gen.scopeValue("root", { ref: root16 });
+          return callRef(cxt, (0, codegen_1._)`${rootName}.validate`, root16, root16.$async);
         }
         function callValidate(sch) {
           const v = getValidate(cxt, sch);
@@ -6516,7 +6516,7 @@ var require_ajv = __commonJS({
     var draft7MetaSchema = require_json_schema_draft_07();
     var META_SUPPORT_DATA = ["/properties"];
     var META_SCHEMA_ID = "http://json-schema.org/draft-07/schema";
-    var Ajv = class extends core_1.default {
+    var Ajv2 = class extends core_1.default {
       _addVocabularies() {
         super._addVocabularies();
         draft7_1.default.forEach((v) => this.addVocabulary(v));
@@ -6535,11 +6535,11 @@ var require_ajv = __commonJS({
         return this.opts.defaultMeta = super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : void 0);
       }
     };
-    exports.Ajv = Ajv;
-    module.exports = exports = Ajv;
-    module.exports.Ajv = Ajv;
+    exports.Ajv = Ajv2;
+    module.exports = exports = Ajv2;
+    module.exports.Ajv = Ajv2;
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.default = Ajv;
+    exports.default = Ajv2;
     var validate_1 = require_validate();
     Object.defineProperty(exports, "KeywordCxt", { enumerable: true, get: function() {
       return validate_1.KeywordCxt;
@@ -6899,7 +6899,7 @@ import { fileURLToPath } from "node:url";
 // package.json
 var package_default = {
   name: "@doist/automations-cli",
-  version: "1.17.1",
+  version: "1.19.0",
   description: "Command-line client for Todoist Automations",
   type: "module",
   bin: {
@@ -6953,13 +6953,13 @@ var package_default = {
   devDependencies: {
     "@doist/automations-core": "*",
     "@doist/automations-sdk": "*",
-    "@types/node": "24.13.6",
+    "@types/node": "24.19.1",
     "conventional-changelog-conventionalcommits": "9.3.1",
     esbuild: "0.28.2",
     "semantic-release": "25.0.9",
     "semantic-release-monorepo": "8.0.2",
     typescript: "6.0.3",
-    vitest: "4.1.11"
+    vitest: "5.0.3"
   },
   engines: {
     node: ">=24"
@@ -7037,6 +7037,10 @@ var API_SCOPES = {
 };
 var API_SCOPE_CODES = Object.keys(API_SCOPES);
 
+// ../../packages/core/dist/esm/constants/cli-client.constants.js
+var AUTOMATIONS_CLI_CLIENT_NAME = "Todoist Automations CLI";
+var AUTOMATIONS_CLI_LOGO_URL = "https://todoist.b-cdn.net/agentist-icons/service_automations-cli_color_192px.png";
+
 // ../../packages/core/dist/esm/constants/connection.constants.js
 var CONNECTION_STATUSES = ["pending", "authorized", "expired", "error"];
 var CONNECTION_TYPES = ["mcp", "trigger", "api"];
@@ -7124,71 +7128,98 @@ var MODEL_CATALOG = {
   "gemini-2.5-flash-lite": {
     provider: "gemini",
     family: "2.5",
-    providerModelId: "gemini-2.5-flash-lite"
+    providerModelId: "gemini-2.5-flash-lite",
+    manifestSelectable: true
   },
   "gemini-2.5-flash": {
     provider: "gemini",
     family: "2.5",
-    providerModelId: "gemini-2.5-flash"
+    providerModelId: "gemini-2.5-flash",
+    manifestSelectable: true
   },
   "gemini-3.1-pro": {
     provider: "gemini",
     family: "3",
-    providerModelId: "gemini-3.1-pro-preview"
+    providerModelId: "gemini-3.1-pro-preview",
+    manifestSelectable: true
   },
   "gemini-3.8-flash": {
     provider: "gemini",
     family: "3",
-    providerModelId: "gemini-3.8-flash"
+    providerModelId: "gemini-3.8-flash",
+    manifestSelectable: true
   },
   "claude-opus-4-6": {
     provider: "anthropic",
     family: "4.6",
-    providerModelId: "claude-opus-4-6"
+    providerModelId: "claude-opus-4-6",
+    manifestSelectable: true
   },
   "claude-sonnet-5": {
     provider: "anthropic",
     family: "5",
-    providerModelId: "claude-sonnet-5"
+    providerModelId: "claude-sonnet-5",
+    manifestSelectable: true
+  },
+  "claude-sonnet-5-5": {
+    provider: "anthropic",
+    family: "5",
+    providerModelId: "claude-sonnet-5-5",
+    manifestSelectable: false
+  },
+  "claude-haiku-5-5": {
+    provider: "anthropic",
+    family: "5",
+    providerModelId: "claude-haiku-5-5",
+    manifestSelectable: false
   },
   "claude-sonnet-4-6": {
     provider: "anthropic",
     family: "4.6",
-    providerModelId: "claude-sonnet-4-6"
+    providerModelId: "claude-sonnet-4-6",
+    manifestSelectable: true
   },
   "claude-haiku-4-5": {
     provider: "anthropic",
     family: "4.5",
-    providerModelId: "claude-haiku-4-5"
+    providerModelId: "claude-haiku-4-5",
+    manifestSelectable: true
   },
   "deepseek-v4-flash": {
     provider: "openrouter",
     family: "deepseek",
-    providerModelId: "deepseek/deepseek-v4-flash-0731"
+    providerModelId: "deepseek/deepseek-v4-flash-0731",
+    manifestSelectable: true
   },
   "deepseek-v4-pro": {
     provider: "openrouter",
     family: "deepseek",
-    providerModelId: "deepseek/deepseek-v4-pro"
+    providerModelId: "deepseek/deepseek-v4-pro",
+    manifestSelectable: true
   },
   "mimo-v2.5": {
     provider: "openrouter",
     family: "mimo",
-    providerModelId: "xiaomi/mimo-v2.5"
+    providerModelId: "xiaomi/mimo-v2.5",
+    manifestSelectable: true
   },
   "mimo-v2.5-pro": {
     provider: "openrouter",
     family: "mimo",
-    providerModelId: "xiaomi/mimo-v2.5-pro"
+    providerModelId: "xiaomi/mimo-v2.5-pro",
+    manifestSelectable: true
   },
   "glm-5.2": {
     provider: "openrouter",
     family: "glm",
-    providerModelId: "z-ai/glm-5.2"
+    providerModelId: "z-ai/glm-5.2",
+    manifestSelectable: true
   }
 };
 var SUPPORTED_LLM_MODELS = Object.keys(MODEL_CATALOG);
 var SUPPORTED_SEARCH_MODELS = SUPPORTED_LLM_MODELS.filter(supportsWebSearch);
+var MANIFEST_LLM_MODELS = SUPPORTED_LLM_MODELS.filter((modelId) => MODEL_CATALOG[modelId].manifestSelectable);
+var MANIFEST_SEARCH_MODELS = MANIFEST_LLM_MODELS.filter((modelId) => supportsWebSearch(modelId));
 function supportsWebSearch(modelId) {
   const { provider } = MODEL_CATALOG[modelId];
   return provider === "gemini" || provider === "anthropic";
@@ -11175,7 +11206,7 @@ function handleIntersectionResults(result, left, right) {
   const unrecKeys = /* @__PURE__ */ new Map();
   let unrecIssue;
   const keyIssues = /* @__PURE__ */ new Map();
-  const collect3 = (iss, side) => {
+  const collect2 = (iss, side) => {
     let keys;
     if (iss.code === "unrecognized_keys" && !iss.path?.length) {
       unrecIssue ?? (unrecIssue = iss);
@@ -11196,11 +11227,11 @@ function handleIntersectionResults(result, left, right) {
     return true;
   };
   for (const iss of left.issues) {
-    if (!collect3(iss, "l"))
+    if (!collect2(iss, "l"))
       result.issues.push(iss);
   }
   for (const iss of right.issues) {
-    if (!collect3(iss, "r"))
+    if (!collect2(iss, "r"))
       result.issues.push(iss);
   }
   const bothKeys = [...unrecKeys].filter(([, f]) => f.l && f.r).map(([k]) => k);
@@ -16503,8 +16534,8 @@ function ko_default() {
 }
 
 // ../../node_modules/zod/v4/locales/lt.js
-var capitalizeFirstCharacter = (text) => {
-  return text.charAt(0).toUpperCase() + text.slice(1);
+var capitalizeFirstCharacter = (text2) => {
+  return text2.charAt(0).toUpperCase() + text2.slice(1);
 };
 function getUnitTypeFromNumber(number4) {
   const abs = Math.abs(number4);
@@ -22861,8 +22892,8 @@ function encodeJSONPointerSegment(segment) {
   return segment.replace(/~/g, "~0").replace(/\//g, "~1");
 }
 function extractDefs(ctx, schema) {
-  const root15 = ctx.seen.get(schema);
-  if (!root15)
+  const root16 = ctx.seen.get(schema);
+  if (!root16)
     throw new Error("Unprocessed schema. This is a bug in Zod.");
   if (ctx.external && ctx.sharedDefsExtractedFor === ctx.external)
     return;
@@ -22891,7 +22922,7 @@ function extractDefs(ctx, schema) {
     }
     const uriPrefix = `#`;
     const defUriPrefix = `${uriPrefix}/${defsSegment}/`;
-    if (entry[1] === root15 && !entry[1].schema.id) {
+    if (entry[1] === root16 && !entry[1].schema.id) {
       return { ref: uriPrefix };
     }
     const defId = entry[1].schema.id ?? `__schema${ctx.counter++}`;
@@ -23062,8 +23093,8 @@ function foldIntersection(json2) {
   assignProps(json2, folded);
 }
 function finalize(ctx, schema) {
-  const root15 = ctx.seen.get(schema);
-  if (!root15)
+  const root16 = ctx.seen.get(schema);
+  if (!root16)
     throw new Error("Unprocessed schema. This is a bug in Zod.");
   const flattenRef = (zodSchema) => {
     const seen = ctx.seen.get(zodSchema);
@@ -23174,7 +23205,7 @@ function finalize(ctx, schema) {
       throw new Error("Schema is missing an `id` property");
     result.$id = ctx.external.uri(id);
   }
-  assignProps(result, root15.defId ? root15.schema : root15.def ?? root15.schema);
+  assignProps(result, root16.defId ? root16.schema : root16.def ?? root16.schema);
   const rootMetaId = ctx.metadataRegistry.get(schema)?.id;
   if (rootMetaId !== void 0 && result.id === rootMetaId)
     delete result.id;
@@ -27675,7 +27706,12 @@ var ConnectorSchema = external_exports.object({
    * connection types — one onboarding covers both action and trigger uses.
    * The FE collapses per-type rows into a single account when this is true.
    */
-  isManaged: external_exports.boolean().optional()
+  isManaged: external_exports.boolean().optional(),
+  /**
+   * The service only admits loopback OAuth clients, so account setup runs in
+   * the Automations CLI on the user's machine instead of the web app.
+   */
+  connectsViaCli: external_exports.boolean().optional()
 });
 var GetConnectorsQuerySchema = external_exports.object({
   query: external_exports.string().optional()
@@ -27701,6 +27737,11 @@ var connectorListResponseSchema = external_exports.object({
   nextCursor: external_exports.string().nullable()
 });
 
+// ../../packages/core/dist/esm/utils/cli-command.js
+function connectViaCliCommand(connectorId, capability) {
+  return `tda connector connect ${connectorId} --capability ${capability}`;
+}
+
 // ../../packages/core/dist/esm/utils/duration.js
 var durationUnits = ["ms", "s", "m", "h", "d", "w"];
 var createDurationPattern = (units) => units.join("|");
@@ -27818,6 +27859,9 @@ function hasTriggerType(value) {
 function isManifestRecord(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
+function isStepWithTools(step) {
+  return "tools" in step && step.tools != null && typeof step.tools === "object";
+}
 function isStringTypedSchema(schema) {
   if (!schema)
     return false;
@@ -27873,6 +27917,180 @@ function resolvePropertySchemaInSchema(schema, propertyPath) {
     return null;
   return resolvePropertySchemaInSchema(propertySchema, remainingPath);
 }
+function parseWebhookTriggerConnector(trigger) {
+  if (trigger.type !== "webhook")
+    return null;
+  const triggerEventId = trigger.event;
+  if (typeof triggerEventId !== "string")
+    return null;
+  const connectorId = triggerEventId.split(".")[0];
+  return connectorId ? { connectorId, triggerEventId } : null;
+}
+function getWebhookTriggerConnectors(manifest) {
+  const triggers = getManifestTriggers(manifest);
+  const results = [];
+  for (const trigger of triggers) {
+    const parsed = parseWebhookTriggerConnector(trigger);
+    if (parsed) {
+      results.push(parsed);
+    }
+  }
+  return results;
+}
+function getRequiredConnectorsFromManifest(manifest) {
+  const requirements = /* @__PURE__ */ new Map();
+  if (manifest.steps) {
+    for (const step of manifest.steps) {
+      if (!isStepWithTools(step))
+        continue;
+      for (const connectorName of Object.keys(step.tools)) {
+        if (!requirements.has(connectorName)) {
+          requirements.set(connectorName, /* @__PURE__ */ new Set());
+        }
+        requirements.get(connectorName)?.add("mcp");
+      }
+    }
+  }
+  for (const { connectorId } of getWebhookTriggerConnectors(manifest)) {
+    if (!requirements.has(connectorId)) {
+      requirements.set(connectorId, /* @__PURE__ */ new Set());
+    }
+    requirements.get(connectorId)?.add("trigger");
+  }
+  return requirements;
+}
+function formatScheduleTime(hour, minute, timeFormat) {
+  return new Intl.DateTimeFormat("en-US", {
+    hour: timeFormat === "24h" ? "2-digit" : "numeric",
+    minute: "2-digit",
+    hour12: timeFormat !== "24h",
+    hourCycle: timeFormat === "24h" ? "h23" : "h12",
+    timeZone: "UTC"
+  }).format(new Date(Date.UTC(2024, 0, 1, hour, minute)));
+}
+function parseIntegerToken(value, min, max) {
+  if (!/^\d+$/.test(value)) {
+    return null;
+  }
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < min || parsed > max) {
+    return null;
+  }
+  return parsed;
+}
+function parseSimpleDayOfWeekList(value) {
+  if (!/^\d(?:,\d)*$/.test(value)) {
+    return null;
+  }
+  const parsed = value.split(",").map((token) => parseIntegerToken(token, 0, 6)).filter((token) => token != null);
+  if (parsed.length === 0 || parsed.length !== new Set(parsed).size) {
+    return null;
+  }
+  return [...parsed].sort((left, right) => left - right);
+}
+function formatList(values) {
+  if (values.length <= 1) {
+    return values[0] ?? "";
+  }
+  if (values.length === 2) {
+    return `${values[0]} and ${values[1]}`;
+  }
+  return `${values.slice(0, -1).join(", ")}, and ${values.at(-1)}`;
+}
+function formatOrdinal(value) {
+  const remainder100 = value % 100;
+  if (remainder100 >= 11 && remainder100 <= 13) {
+    return `${value}th`;
+  }
+  switch (value % 10) {
+    case 1:
+      return `${value}st`;
+    case 2:
+      return `${value}nd`;
+    case 3:
+      return `${value}rd`;
+    default:
+      return `${value}th`;
+  }
+}
+function formatDuration(value) {
+  const match = value.match(/^(\d+)(ms|s|m|h|d|w)$/);
+  if (!match) {
+    return value;
+  }
+  const [, rawAmount, unit] = match;
+  const amount = Number(rawAmount);
+  const unitLabelMap = {
+    ms: amount === 1 ? "millisecond" : "milliseconds",
+    s: amount === 1 ? "second" : "seconds",
+    m: amount === 1 ? "minute" : "minutes",
+    h: amount === 1 ? "hour" : "hours",
+    d: amount === 1 ? "day" : "days",
+    w: amount === 1 ? "week" : "weeks"
+  };
+  return `${amount} ${unitLabelMap[unit]}`;
+}
+function describeIntervalSchedule(value) {
+  if (!value.includes("/")) {
+    return `Runs every ${formatDuration(value)}`;
+  }
+  const [offset, interval] = value.split("/");
+  if (!offset || !interval) {
+    return `Runs on schedule: ${value}`;
+  }
+  return `Runs every ${formatDuration(interval)}, starting ${formatDuration(offset)} after activation`;
+}
+function describeCronSchedule(value, timeFormat) {
+  const [minute, hour, dayOfMonth, month, dayOfWeek, extra] = value.expression.trim().split(/\s+/);
+  if (!minute || !hour || !dayOfMonth || !month || !dayOfWeek || extra) {
+    return `Runs on cron schedule ${value.expression} (${value.timezone})`;
+  }
+  const minuteNumber = parseIntegerToken(minute, 0, 59);
+  const hourNumber = parseIntegerToken(hour, 0, 23);
+  if (minuteNumber == null || hourNumber == null || month !== "*") {
+    return `Runs on cron schedule ${value.expression} (${value.timezone})`;
+  }
+  const time3 = formatScheduleTime(hourNumber, minuteNumber, timeFormat);
+  const timezone = value.timezone;
+  const weekdayNames = [
+    "Sunday",
+    "Monday",
+    "Tuesday",
+    "Wednesday",
+    "Thursday",
+    "Friday",
+    "Saturday"
+  ];
+  if (dayOfMonth === "*" && dayOfWeek === "*") {
+    return `Runs every day at ${time3} in ${timezone}`;
+  }
+  if (dayOfMonth === "*" && dayOfWeek === "1-5") {
+    return `Runs every weekday at ${time3} in ${timezone}`;
+  }
+  if (dayOfMonth === "*") {
+    const daysOfWeek = parseSimpleDayOfWeekList(dayOfWeek);
+    if (!daysOfWeek || daysOfWeek.length === 0) {
+      return `Runs on cron schedule ${value.expression} (${value.timezone})`;
+    }
+    const dayNames = daysOfWeek.map((day) => weekdayNames[day] ?? String(day));
+    return `Runs every ${formatList(dayNames)} at ${time3} in ${timezone}`;
+  }
+  if (dayOfWeek === "*") {
+    const numericDayOfMonth = parseIntegerToken(dayOfMonth, 1, 31);
+    if (numericDayOfMonth == null) {
+      return `Runs on cron schedule ${value.expression} (${value.timezone})`;
+    }
+    return `Runs every month on the ${formatOrdinal(numericDayOfMonth)} at ${time3} in ${timezone}`;
+  }
+  return `Runs on cron schedule ${value.expression} (${value.timezone})`;
+}
+function getScheduleTriggerDescription(params) {
+  const { value, timeFormat } = params;
+  if (typeof value === "string") {
+    return describeIntervalSchedule(value);
+  }
+  return describeCronSchedule(value, timeFormat);
+}
 
 // ../../packages/core/dist/esm/schemas/manifest.schema.js
 var uuidv7Regex = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-7[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$/i;
@@ -28068,7 +28286,7 @@ var baseStepSchema = external_exports.object({
   })
 });
 var MODEL_TIERS = ["lite", "flash", "pro"];
-var SUPPORTED_MODEL_REFERENCES = [...MODEL_TIERS, ...SUPPORTED_LLM_MODELS];
+var SUPPORTED_MODEL_REFERENCES = [...MODEL_TIERS, ...MANIFEST_LLM_MODELS];
 var modelReferenceSchema = external_exports.enum(SUPPORTED_MODEL_REFERENCES).meta({
   description: "A stable model tier (lite, flash, pro) or a supported literal model override."
 });
@@ -28124,7 +28342,7 @@ var searchStepSchema = baseStepSchema.merge(external_exports.object({
     description: "The search prompt to execute using web search."
   }),
   outputSchema: searchStepOutputSchema,
-  model: external_exports.enum([...MODEL_TIERS, ...SUPPORTED_SEARCH_MODELS]).optional().meta({
+  model: external_exports.enum([...MODEL_TIERS, ...MANIFEST_SEARCH_MODELS]).optional().meta({
     description: "A stable tier (lite, flash, pro) or a supported search-enabled literal model override."
   })
 }));
@@ -28248,9 +28466,9 @@ var partialManifestSchema = manifestSchemaBase.partial().extend({
 var templateVariableRegex = /\{\{\s*[\w.]+\s*\}\}/g;
 var codeStepReferenceRegex = /\bsteps\.([a-zA-Z][a-zA-Z0-9]*)(?:\.([a-zA-Z_][\w.]*))?/g;
 var backtickStepReferenceRegex = /`steps\.([a-zA-Z][a-zA-Z0-9]*)(?:\.([a-zA-Z_][\w.]*))?`/g;
-function extractStepReferences(text, regex) {
+function extractStepReferences(text2, regex) {
   const references = [];
-  for (const match of text.matchAll(regex)) {
+  for (const match of text2.matchAll(regex)) {
     const stepId = match[1];
     if (!stepId)
       continue;
@@ -28296,8 +28514,8 @@ function validateTemplateVariable({ variable, context, stepId, currentStepGuard,
   if (parts.length === 0) {
     return null;
   }
-  const [root15, ...rest] = parts;
-  if (root15 === "trigger") {
+  const [root16, ...rest] = parts;
+  if (root16 === "trigger") {
     if (rest.length === 0) {
       return `Step "${stepId}" ${sourceType} references "{{trigger}}" without a property. Use {{trigger.<property>}} syntax (e.g., {{trigger.payload}}, {{trigger.metadata}}).`;
     }
@@ -28320,7 +28538,7 @@ function validateTemplateVariable({ variable, context, stepId, currentStepGuard,
     }
     return null;
   }
-  if (root15 === "steps") {
+  if (root16 === "steps") {
     const referencedStepId = rest[0];
     if (!referencedStepId) {
       return `Step "${stepId}" ${sourceType} references "steps" but is missing the step identifier in template variable "{{${variable}}}". Use {{steps.<stepId>}} syntax.`;
@@ -28753,6 +28971,29 @@ var CreateConnectionParamsSchema = external_exports.object({
 var CreateConnectionBodySchema = external_exports.object({
   automationIds: external_exports.array(external_exports.uuid()).optional()
 });
+var ImportLocalOAuthConnectionBodySchema = external_exports.object({
+  /** The public client the CLI registered; the server bound the grant to it. */
+  clientId: external_exports.string().min(1),
+  accessToken: external_exports.string().min(1),
+  refreshToken: external_exports.string().min(1).optional(),
+  /** Seconds until `accessToken` expires, as the token endpoint reported it. */
+  expiresIn: external_exports.number().int().positive().optional(),
+  /**
+   * A broken connection of the caller's, for the same connector, whose
+   * automation bindings move to the new grant when the account cannot be
+   * matched to it.
+   */
+  repairConnectionId: external_exports.uuid().optional()
+});
+var LocalOAuthSetupSchema = external_exports.object({
+  /** RFC 7591 registration endpoint; null when the server offers none. */
+  registrationEndpoint: external_exports.string().url().nullable(),
+  authorizationEndpoint: external_exports.string().url(),
+  tokenEndpoint: external_exports.string().url(),
+  /** RFC 8707 resource indicator for the MCP server, when it advertises one. */
+  resource: external_exports.string().url().nullable(),
+  scopes: external_exports.array(external_exports.string())
+});
 var OAuthConnectionSetupSchema = external_exports.object({
   kind: external_exports.literal("oauth"),
   authorizationUrl: external_exports.string().url()
@@ -29084,6 +29325,17 @@ var finalizeAutomationDraftResponseSchema = external_exports.object({
 var testAutomationDraftResponseSchema = external_exports.object({
   success: external_exports.literal(true)
 });
+var AUTOMATION_OPEN_DRAFT_CONFLICT_CODE = "automation_open_draft_conflict";
+var AutomationOpenDraftConflictSchema = external_exports.object({
+  code: external_exports.literal(AUTOMATION_OPEN_DRAFT_CONFLICT_CODE),
+  message: external_exports.string(),
+  draftId: external_exports.string()
+});
+var AUTOMATION_DRAFT_NOT_READY_CODE = "automation_draft_not_ready";
+var AutomationDraftNotReadySchema = external_exports.object({
+  code: external_exports.literal(AUTOMATION_DRAFT_NOT_READY_CODE),
+  message: external_exports.string()
+});
 
 // ../../packages/core/dist/esm/schemas/automation-draft-connection.schema.js
 var CreateAutomationDraftConnectionSchema = external_exports.object({
@@ -29572,7 +29824,9 @@ var FRONTEND_COHORT_EVENTS = [
   "chat:sent",
   "automation:repaired",
   "template:used",
-  "top-up:completed"
+  "top-up:completed",
+  "guided-creation:started",
+  "guided-creation:completed"
 ];
 var BACKEND_COHORT_EVENTS = [
   // API-process (publish lifecycle)
@@ -29725,7 +29979,143 @@ function assertKnownTimezone(timezone) {
 }
 
 // ../../packages/core/dist/esm/schemas/manifest.validation.js
+var import_ajv = __toESM(require_ajv(), 1);
 var import_ajv_formats = __toESM(require_dist(), 1);
+function validateManifest(manifest) {
+  const allErrors = [];
+  try {
+    const validatedManifest = manifestSchema.parse(manifest);
+    const triggerValidation = validateTriggerSchemas(validatedManifest);
+    if (!triggerValidation.isValid) {
+      allErrors.push(...triggerValidation.errors);
+    }
+    const stepValidation = validateStepSchemas(validatedManifest);
+    if (!stepValidation.isValid) {
+      allErrors.push(...stepValidation.errors);
+    }
+    const payloadValidation = validateWebhookPayloadStructure(validatedManifest);
+    if (!payloadValidation.isValid) {
+      allErrors.push(...payloadValidation.errors);
+    }
+    return {
+      isValid: allErrors.length === 0,
+      errors: allErrors
+    };
+  } catch (error62) {
+    if (error62 instanceof external_exports.ZodError) {
+      const zodErrors = error62.issues.map((err) => `${err.path.join(".")}: ${err.message}`);
+      return { isValid: false, errors: zodErrors };
+    }
+    const message = error62 instanceof Error ? error62.message : "Unknown validation error";
+    return { isValid: false, errors: [message] };
+  }
+}
+function validatePartialManifest(manifest) {
+  try {
+    const data = partialManifestSchema.parse(manifest);
+    return { isValid: true, errors: [], data };
+  } catch (error62) {
+    if (error62 instanceof external_exports.ZodError) {
+      const errors = error62.issues.map((err) => `${err.path.join(".")}: ${err.message}`);
+      return { isValid: false, errors };
+    }
+    const message = error62 instanceof Error ? error62.message : "Unknown validation error";
+    return { isValid: false, errors: [message] };
+  }
+}
+function compileSchema(schema, schemaName) {
+  const ajv = new import_ajv.Ajv({ strict: true, validateFormats: true });
+  import_ajv_formats.default.default(ajv);
+  try {
+    ajv.compile(schema);
+    return { isValid: true };
+  } catch (error62) {
+    const message = error62 instanceof Error ? error62.message : String(error62);
+    return {
+      isValid: false,
+      error: `${schemaName} is invalid JSON Schema: ${message}. Common issue: when using array keywords like "contains", you must explicitly declare "type": "array".`
+    };
+  }
+}
+function validateTriggerSchemas(manifest) {
+  const errors = [];
+  const triggers = getManifestTriggers(manifest);
+  if (triggers.length === 0) {
+    return { isValid: true, errors: [] };
+  }
+  for (const trigger of triggers) {
+    if (trigger.type === "webhook" || trigger.type === "api") {
+      const triggerLabel = trigger.type === "webhook" ? `Webhook trigger (${trigger.type === "webhook" ? trigger.event : ""})` : "API trigger";
+      const outputResult = compileSchema(trigger.outputSchema, `${triggerLabel} outputSchema`);
+      if (!outputResult.isValid && outputResult.error) {
+        errors.push(outputResult.error);
+      }
+      if (trigger.inputSchema) {
+        const inputResult = compileSchema(trigger.inputSchema, `${triggerLabel} inputSchema`);
+        if (!inputResult.isValid && inputResult.error) {
+          errors.push(inputResult.error);
+        }
+      }
+    }
+  }
+  return {
+    isValid: errors.length === 0,
+    errors
+  };
+}
+function validateStepSchemas(manifest) {
+  const errors = [];
+  if (!manifest.steps || !Array.isArray(manifest.steps)) {
+    return { isValid: true, errors: [] };
+  }
+  for (const step of manifest.steps) {
+    const outputResult = compileSchema(step.outputSchema, `Step "${step.id}" outputSchema`);
+    if (!outputResult.isValid && outputResult.error) {
+      errors.push(outputResult.error);
+    }
+    if (step.exitOn) {
+      const exitOnResult = compileSchema(step.exitOn, `Step "${step.id}" exitOn`);
+      if (!exitOnResult.isValid && exitOnResult.error) {
+        errors.push(exitOnResult.error);
+      }
+    }
+  }
+  return {
+    isValid: errors.length === 0,
+    errors
+  };
+}
+function validateWebhookPayloadStructure(manifest) {
+  const errors = [];
+  const triggers = getManifestTriggers(manifest);
+  const webhookTriggers = triggers.filter((t) => t.type === "webhook");
+  if (webhookTriggers.length === 0) {
+    return { isValid: true, errors: [] };
+  }
+  for (const trigger of webhookTriggers) {
+    if (trigger.type !== "webhook")
+      continue;
+    const eventLabel = trigger.event;
+    const triggerOutputSchema = trigger.outputSchema;
+    if (!triggerOutputSchema) {
+      errors.push(`Webhook trigger "${eventLabel}" is missing outputSchema`);
+      continue;
+    }
+    if (!triggerOutputSchema.properties || typeof triggerOutputSchema.properties !== "object") {
+      errors.push(`Webhook trigger "${eventLabel}" outputSchema must have a "properties" field with a "payload" object. The webhook event data is wrapped in a payload field.`);
+      continue;
+    }
+    const payloadSchema = triggerOutputSchema.properties.payload;
+    if (!payloadSchema || typeof payloadSchema !== "object") {
+      errors.push(`Webhook trigger "${eventLabel}" outputSchema must have a "payload" property. All webhook event data is wrapped in { payload: {...}, metadata: {...} }.`);
+      continue;
+    }
+    if (!Array.isArray(triggerOutputSchema.required) || !triggerOutputSchema.required.includes("payload")) {
+      errors.push(`Webhook trigger "${eventLabel}" outputSchema must include "payload" in the "required" array. The payload wrapper is mandatory.`);
+    }
+  }
+  return { isValid: errors.length === 0, errors };
+}
 
 // ../../packages/core/dist/esm/schemas/notification.schema.js
 var NOTIFICATION_TYPES = ["notification", "prompt"];
@@ -30528,13 +30918,13 @@ function buildUrl(baseUrl, path, query) {
   return url2.toString();
 }
 async function readResponseBody(response) {
-  const text = await response.text();
-  if (text.length === 0)
+  const text2 = await response.text();
+  if (text2.length === 0)
     return void 0;
   try {
-    return JSON.parse(text);
+    return JSON.parse(text2);
   } catch {
-    return text;
+    return text2;
   }
 }
 async function request(args) {
@@ -30723,6 +31113,16 @@ var automationDraftsEndpoints = {
 };
 
 // ../../packages/sdk/dist/esm/clients/automation-drafts/automation-drafts-client.js
+function toCreateQuery(translate) {
+  return translate === void 0 ? void 0 : { translate };
+}
+function getDraftNotReadyError(error62) {
+  if (!(error62 instanceof AutomationsRequestError) || error62.httpStatusCode !== 400) {
+    return null;
+  }
+  const parsed = AutomationDraftNotReadySchema.safeParse(error62.responseData);
+  return parsed.success ? parsed.data : null;
+}
 var AutomationDraftsClient = class extends BaseClient {
   async list(args = {}, options) {
     const { cursor, limit } = CursorPaginationSchema.parse(args);
@@ -30745,11 +31145,13 @@ var AutomationDraftsClient = class extends BaseClient {
   }
   async create(manifest, options) {
     const body = partialManifestSchema.parse(manifest);
+    const { translate, ...requestOptions } = options ?? {};
     const data = await this.request({
       method: "POST",
       path: automationDraftsEndpoints.list,
+      query: toCreateQuery(translate),
       body,
-      options
+      options: requestOptions
     });
     return automationDraftWithValidationSchema.parse(data);
   }
@@ -30852,6 +31254,13 @@ var automationsEndpoints = {
 
 // ../../packages/sdk/dist/esm/clients/automations/automations-client.js
 var createDraftResponseSchema = external_exports.object({ draft: automationDraftSchema });
+function getOpenDraftConflictError(error62) {
+  if (!(error62 instanceof AutomationsRequestError) || error62.httpStatusCode !== 409) {
+    return null;
+  }
+  const parsed = AutomationOpenDraftConflictSchema.safeParse(error62.responseData);
+  return parsed.success ? parsed.data : null;
+}
 var AutomationsClient = class extends BaseClient {
   async list(args = {}, options) {
     const { cursor, limit } = CursorPaginationSchema.parse(args);
@@ -31030,11 +31439,23 @@ var WorkspaceAutomationRunsClient = class extends BaseClient {
 
 // ../../packages/sdk/dist/esm/clients/workspace-automation-draft-connections/endpoints.js
 var workspaceAutomationDraftConnectionsEndpoints = {
-  list: (workspaceId, draftId) => `/workspaces/${encodeURIComponent(workspaceId)}/automation-drafts/${encodeURIComponent(draftId)}/connections`
+  list: (workspaceId, draftId) => root6(workspaceId, draftId),
+  status: (workspaceId, draftId) => `${root6(workspaceId, draftId)}/status`
 };
+function root6(workspaceId, draftId) {
+  return `/workspaces/${encodeURIComponent(workspaceId)}/automation-drafts/${encodeURIComponent(draftId)}/connections`;
+}
 
 // ../../packages/sdk/dist/esm/clients/workspace-automation-draft-connections/workspace-automation-draft-connections-client.js
 var WorkspaceAutomationDraftConnectionsClient = class extends BaseClient {
+  async list(workspaceId, draftId, options) {
+    const data = await this.request({
+      method: "GET",
+      path: workspaceAutomationDraftConnectionsEndpoints.list(IdSchema.parse(workspaceId), IdSchema.parse(draftId)),
+      options
+    });
+    return GetAutomationDraftConnectionsResponseSchema.parse(data);
+  }
   async upsert(workspaceId, draftId, body, options) {
     const parsedBody = CreateAutomationDraftConnectionSchema.parse(body);
     const data = await this.request({
@@ -31045,14 +31466,23 @@ var WorkspaceAutomationDraftConnectionsClient = class extends BaseClient {
     });
     return AutomationDraftConnectionSchema.parse(data);
   }
+  async getStatus(workspaceId, draftId, options) {
+    const data = await this.request({
+      method: "GET",
+      path: workspaceAutomationDraftConnectionsEndpoints.status(IdSchema.parse(workspaceId), IdSchema.parse(draftId)),
+      options
+    });
+    return GetAutomationDraftConnectionValidationResponseSchema.parse(data);
+  }
 };
 
 // ../../packages/sdk/dist/esm/clients/workspace-automation-drafts/endpoints.js
 var workspaceAutomationDraftsEndpoints = {
-  list: (workspaceId) => `${root6(workspaceId)}`,
-  detail: (workspaceId, id) => `${root6(workspaceId)}/${encodeURIComponent(id)}`
+  list: (workspaceId) => `${root7(workspaceId)}`,
+  detail: (workspaceId, id) => `${root7(workspaceId)}/${encodeURIComponent(id)}`,
+  finalize: (workspaceId, id) => `${root7(workspaceId)}/${encodeURIComponent(id)}/finalize`
 };
-function root6(workspaceId) {
+function root7(workspaceId) {
   return `/workspaces/${encodeURIComponent(workspaceId)}/automation-drafts`;
 }
 
@@ -31076,6 +31506,29 @@ var WorkspaceAutomationDraftsClient = class extends BaseClient {
     });
     return automationDraftWithValidationSchema.parse(data);
   }
+  async create(workspaceId, manifest, options) {
+    const body = partialManifestSchema.parse(manifest);
+    const { translate, ...requestOptions } = options ?? {};
+    const data = await this.request({
+      method: "POST",
+      path: workspaceAutomationDraftsEndpoints.list(IdSchema.parse(workspaceId)),
+      // Only sent when set, so a default create is unchanged on the wire.
+      query: translate === void 0 ? void 0 : { translate },
+      body,
+      options: requestOptions
+    });
+    return automationDraftWithValidationSchema.parse(data);
+  }
+  async update(workspaceId, draftId, manifest, options) {
+    const body = partialManifestSchema.parse(manifest);
+    const data = await this.request({
+      method: "PUT",
+      path: workspaceAutomationDraftsEndpoints.detail(IdSchema.parse(workspaceId), IdSchema.parse(draftId)),
+      body,
+      options
+    });
+    return automationDraftWithValidationSchema.parse(data);
+  }
   /** Deletes the draft. Only its owner can; the API answers 404 otherwise. */
   async delete(workspaceId, draftId, options) {
     await this.request({
@@ -31084,6 +31537,15 @@ var WorkspaceAutomationDraftsClient = class extends BaseClient {
       options
     });
   }
+  /** Publishes the draft as a workspace automation, or updates the one it edits. */
+  async finalize(workspaceId, draftId, options) {
+    const data = await this.request({
+      method: "POST",
+      path: workspaceAutomationDraftsEndpoints.finalize(IdSchema.parse(workspaceId), IdSchema.parse(draftId)),
+      options
+    });
+    return finalizeAutomationDraftResponseSchema.parse(data);
+  }
 };
 
 // ../../packages/sdk/dist/esm/clients/workspace-chat/endpoints.js
@@ -31107,15 +31569,16 @@ var WorkspaceChatClient = class extends BaseClient {
 
 // ../../packages/sdk/dist/esm/clients/workspace-automations/endpoints.js
 var workspaceAutomationsEndpoints = {
-  list: (workspaceId) => `${root7(workspaceId)}`,
-  detail: (workspaceId, id) => `${root7(workspaceId)}/${encodeURIComponent(id)}`,
-  metadata: (workspaceId, id) => `${root7(workspaceId)}/${encodeURIComponent(id)}/metadata`,
-  schedule: (workspaceId, id) => `${root7(workspaceId)}/${encodeURIComponent(id)}/schedule`,
-  visibility: (workspaceId, id) => `${root7(workspaceId)}/${encodeURIComponent(id)}/visibility`,
-  move: (workspaceId, id) => `${root7(workspaceId)}/${encodeURIComponent(id)}/move`,
-  trigger: (workspaceId, id) => `${root7(workspaceId)}/${encodeURIComponent(id)}/trigger`
+  list: (workspaceId) => `${root8(workspaceId)}`,
+  detail: (workspaceId, id) => `${root8(workspaceId)}/${encodeURIComponent(id)}`,
+  metadata: (workspaceId, id) => `${root8(workspaceId)}/${encodeURIComponent(id)}/metadata`,
+  schedule: (workspaceId, id) => `${root8(workspaceId)}/${encodeURIComponent(id)}/schedule`,
+  visibility: (workspaceId, id) => `${root8(workspaceId)}/${encodeURIComponent(id)}/visibility`,
+  move: (workspaceId, id) => `${root8(workspaceId)}/${encodeURIComponent(id)}/move`,
+  trigger: (workspaceId, id) => `${root8(workspaceId)}/${encodeURIComponent(id)}/trigger`,
+  draft: (workspaceId, id) => `${root8(workspaceId)}/${encodeURIComponent(id)}/draft`
 };
-function root7(workspaceId) {
+function root8(workspaceId) {
   return `/workspaces/${encodeURIComponent(workspaceId)}/automations`;
 }
 
@@ -31213,12 +31676,33 @@ var WorkspaceAutomationsClient = class extends BaseClient {
       options
     });
   }
+  /** The edit draft currently open for the automation, if any (404 otherwise). */
+  async getDraft(workspaceId, id, options) {
+    const data = await this.request({
+      method: "GET",
+      path: workspaceAutomationsEndpoints.draft(IdSchema.parse(workspaceId), IdSchema.parse(id)),
+      options
+    });
+    return automationDraftSchema.parse(data);
+  }
+  /**
+   * Opens an edit draft seeded from the published manifest. Answers 409 when
+   * one is already open; see `getOpenDraftConflictError`.
+   */
+  async createDraft(workspaceId, id, options) {
+    const data = await this.request({
+      method: "POST",
+      path: workspaceAutomationsEndpoints.draft(IdSchema.parse(workspaceId), IdSchema.parse(id)),
+      options
+    });
+    return createDraftResponseSchema.parse(data);
+  }
 };
 
 // ../../packages/sdk/dist/esm/clients/workspaces/endpoints.js
-var root8 = "/workspaces";
+var root9 = "/workspaces";
 var workspacesEndpoints = {
-  list: root8
+  list: root9
 };
 
 // ../../packages/sdk/dist/esm/clients/workspaces/workspaces-client.js
@@ -31240,12 +31724,12 @@ var WorkspacesClient = class extends BaseClient {
 };
 
 // ../../packages/sdk/dist/esm/clients/chat/endpoints.js
-var root9 = "/chat/conversations";
+var root10 = "/chat/conversations";
 var chatEndpoints = {
-  conversations: root9,
-  conversation: (id) => `${root9}/${encodeURIComponent(id)}`,
-  messages: (id) => `${root9}/${encodeURIComponent(id)}/messages`,
-  usagePreview: (id) => `${root9}/${encodeURIComponent(id)}/usage-preview`
+  conversations: root10,
+  conversation: (id) => `${root10}/${encodeURIComponent(id)}`,
+  messages: (id) => `${root10}/${encodeURIComponent(id)}/messages`,
+  usagePreview: (id) => `${root10}/${encodeURIComponent(id)}/usage-preview`
 };
 
 // ../../packages/sdk/dist/esm/clients/chat/chat-client.js
@@ -31319,14 +31803,15 @@ var ChatClient = class extends BaseClient {
 };
 
 // ../../packages/sdk/dist/esm/clients/connections/endpoints.js
-var root10 = "/connections";
+var root11 = "/connections";
 var connectionsEndpoints = {
-  list: root10,
-  detail: (id) => `${root10}/${encodeURIComponent(id)}`,
-  token: (id) => `${root10}/${encodeURIComponent(id)}/token`,
-  dependentAutomations: (connectorId) => `${root10}/${encodeURIComponent(connectorId)}/automations`,
-  create: (connectorId, capability) => `${root10}/${encodeURIComponent(connectorId)}/${encodeURIComponent(capability)}`,
-  checkManifest: `${root10}/check-manifest`
+  list: root11,
+  detail: (id) => `${root11}/${encodeURIComponent(id)}`,
+  token: (id) => `${root11}/${encodeURIComponent(id)}/token`,
+  dependentAutomations: (connectorId) => `${root11}/${encodeURIComponent(connectorId)}/automations`,
+  create: (connectorId, capability) => `${root11}/${encodeURIComponent(connectorId)}/${encodeURIComponent(capability)}`,
+  localOAuth: (connectorId, capability) => `${root11}/${encodeURIComponent(connectorId)}/${encodeURIComponent(capability)}/local-oauth`,
+  checkManifest: `${root11}/check-manifest`
 };
 
 // ../../packages/sdk/dist/esm/clients/connections/connections-client.js
@@ -31405,6 +31890,41 @@ var ConnectionsClient = class extends BaseClient {
     });
     return CreateConnectionResponseSchema.parse(data);
   }
+  /**
+   * The authorization server endpoints and scopes for running a
+   * `connectsViaCli` connector's OAuth flow with a loopback client.
+   */
+  async getLocalOAuthSetup(args, options) {
+    const { connectorId, capability } = CreateConnectionParamsSchema.parse({
+      connectorId: IdSchema.parse(args.connectorId),
+      capability: args.capability
+    });
+    const data = await this.request({
+      method: "GET",
+      path: connectionsEndpoints.localOAuth(connectorId, capability),
+      options
+    });
+    return LocalOAuthSetupSchema.parse(data);
+  }
+  /**
+   * Stores a grant the CLI obtained with a loopback OAuth client, for a
+   * connector whose authorization server admits no hosted clients
+   * (`connectsViaCli`). The connection comes back already authorized.
+   */
+  async importLocalOAuth(args, options) {
+    const { connectorId, capability } = CreateConnectionParamsSchema.parse({
+      connectorId: IdSchema.parse(args.connectorId),
+      capability: args.capability
+    });
+    const body = ImportLocalOAuthConnectionBodySchema.parse(args.grant);
+    const data = await this.request({
+      method: "POST",
+      path: connectionsEndpoints.localOAuth(connectorId, capability),
+      body,
+      options
+    });
+    return CreateConnectionResponseSchema.parse(data);
+  }
   async checkManifest(manifest, options) {
     const parsedManifest = partialManifestSchema.parse(manifest);
     const data = await this.request({
@@ -31478,12 +31998,12 @@ function createClientContext(authToken, options = {}, apiOrigin = "automations")
 }
 
 // ../../packages/sdk/dist/esm/clients/notifications/endpoints.js
-var root11 = "/notifications";
+var root12 = "/notifications";
 var notificationsEndpoints = {
-  list: root11,
-  pendingPromptAutomations: `${root11}/pending-prompt-automations`,
-  detail: (id) => `${root11}/${encodeURIComponent(id)}`,
-  respond: (id) => `${root11}/${encodeURIComponent(id)}/respond`
+  list: root12,
+  pendingPromptAutomations: `${root12}/pending-prompt-automations`,
+  detail: (id) => `${root12}/${encodeURIComponent(id)}`,
+  respond: (id) => `${root12}/${encodeURIComponent(id)}/respond`
 };
 var pushRoot = "/push-subscriptions";
 var pushSubscriptionsEndpoints = {
@@ -31607,11 +32127,11 @@ var NotificationsClient = class extends BaseClient {
 };
 
 // ../../packages/sdk/dist/esm/clients/user-settings/endpoints.js
-var root12 = "/settings";
+var root13 = "/settings";
 var userSettingsEndpoints = {
-  onboarding: `${root12}/onboarding`,
-  preferences: `${root12}/preferences`,
-  terms: `${root12}/terms`
+  onboarding: `${root13}/onboarding`,
+  preferences: `${root13}/preferences`,
+  terms: `${root13}/terms`
 };
 
 // ../../packages/sdk/dist/esm/clients/user-settings/user-settings-client.js
@@ -31773,11 +32293,11 @@ var UsageBillingClient = class extends BaseClient {
 };
 
 // ../../packages/sdk/dist/esm/clients/webhook-event-subscriptions/endpoints.js
-var root13 = "/webhook-event-subscriptions";
+var root14 = "/webhook-event-subscriptions";
 var webhookEventSubscriptionsEndpoints = {
-  list: root13,
-  detail: (id) => `${root13}/${encodeURIComponent(id)}`,
-  deliveries: (id) => `${root13}/${encodeURIComponent(id)}/deliveries`
+  list: root14,
+  detail: (id) => `${root14}/${encodeURIComponent(id)}`,
+  deliveries: (id) => `${root14}/${encodeURIComponent(id)}/deliveries`
 };
 
 // ../../packages/sdk/dist/esm/clients/webhook-event-subscriptions/webhook-event-subscriptions-client.js
@@ -31850,12 +32370,12 @@ var WebhookEventSubscriptionsClient = class extends BaseClient {
 };
 
 // ../../packages/sdk/dist/esm/clients/webhook-subscriptions/endpoints.js
-function root14(automationId) {
+function root15(automationId) {
   return `/automations/${encodeURIComponent(automationId)}/subscriptions`;
 }
 var webhookSubscriptionsEndpoints = {
-  list: (automationId) => root14(automationId),
-  detail: (automationId, subscriptionId) => `${root14(automationId)}/${encodeURIComponent(subscriptionId)}`
+  list: (automationId) => root15(automationId),
+  detail: (automationId, subscriptionId) => `${root15(automationId)}/${encodeURIComponent(subscriptionId)}`
 };
 
 // ../../packages/sdk/dist/esm/clients/webhook-subscriptions/webhook-subscriptions-client.js
@@ -33849,8 +34369,8 @@ function getResourceName(manifest) {
 }
 function getMessageSummary(message) {
   if (!Array.isArray(message.parts)) return "(unstructured message parts)";
-  const text = message.parts.filter(isTextPart).map((part) => part.text).join("");
-  if (text) return text;
+  const text2 = message.parts.filter(isTextPart).map((part) => part.text).join("");
+  if (text2) return text2;
   const partTypes = message.parts.filter(isRecord2).map((part) => typeof part.type === "string" ? part.type : "unknown");
   return partTypes.length > 0 ? `[${partTypes.join(", ")}]` : "(no visible text)";
 }
@@ -34205,6 +34725,36 @@ async function runStreamingCommand(command, handlers) {
   }
 }
 
+// src/lib/connection-selection.ts
+function parseConnectionSelectionOption(value) {
+  const separatorIndex = value.indexOf("=");
+  if (separatorIndex <= 0 || separatorIndex === value.length - 1) {
+    throw new Error(
+      `Invalid connection selection "${value}". Use connector[:mcp|trigger]=connection-id.`
+    );
+  }
+  const selector = value.slice(0, separatorIndex);
+  const connectionId = value.slice(separatorIndex + 1);
+  const selectorParts = selector.split(":");
+  if (selectorParts.length > 2) {
+    throw new Error(`Invalid connection selection "${value}".`);
+  }
+  const [connectorId, rawConnectionType] = selectorParts;
+  if (!connectorId) throw new Error(`Invalid connection selection "${value}".`);
+  if (rawConnectionType && rawConnectionType !== "mcp" && rawConnectionType !== "trigger") {
+    throw new Error(`Invalid connection type "${rawConnectionType}".`);
+  }
+  const connectionType = rawConnectionType === "mcp" || rawConnectionType === "trigger" ? rawConnectionType : void 0;
+  return {
+    connectorId,
+    connectionType,
+    connectionId
+  };
+}
+function collectOption(value, previous) {
+  return [...previous, value];
+}
+
 // ../../packages/sdk/dist/esm/chat-turn/connection-requirements.js
 var CONNECTION_LOOKUP_CONCURRENCY = 4;
 function deduplicateConnectionRequirements(requirements) {
@@ -34313,11 +34863,11 @@ var toolUpdateMemoryResultSchema = external_exports.object({
 });
 
 // ../../packages/sdk/dist/esm/chat-turn/messages.js
-function createUserMessage(text) {
+function createUserMessage(text2) {
   return {
     id: globalThis.crypto.randomUUID(),
     role: "user",
-    parts: [{ type: "text", text }]
+    parts: [{ type: "text", text: text2 }]
   };
 }
 function toUiMessage(message) {
@@ -34842,8 +35392,8 @@ Interrupted. Resume with: tda chat continue ${sanitizeTerminalText(event.convers
         this.assistantLineOpen = false;
         break;
       case "session_status": {
-        const text = sanitizeTerminalText(String(event.humanText ?? ""));
-        this.stream.write(text.endsWith("\n") ? text : `${text}
+        const text2 = sanitizeTerminalText(String(event.humanText ?? ""));
+        this.stream.write(text2.endsWith("\n") ? text2 : `${text2}
 `);
         break;
       }
@@ -35374,9 +35924,9 @@ var ChatService = class {
         input: input2,
         pendingAction,
         signal,
-        onText: (text) => {
+        onText: (text2) => {
           markActivity();
-          this.output.emit({ type: "assistant_text", conversationId, text });
+          this.output.emit({ type: "assistant_text", conversationId, text: text2 });
         },
         onToolActivity: (activity) => {
           markActivity();
@@ -35557,31 +36107,6 @@ function getResumeCommand(summary) {
   }
   return `tda chat continue ${summary.conversationId} "<message>"`;
 }
-function parseConnectionSelectionOption(value) {
-  const separatorIndex = value.indexOf("=");
-  if (separatorIndex <= 0 || separatorIndex === value.length - 1) {
-    throw new Error(
-      `Invalid connection selection "${value}". Use connector[:mcp|trigger]=connection-id.`
-    );
-  }
-  const selector = value.slice(0, separatorIndex);
-  const connectionId = value.slice(separatorIndex + 1);
-  const selectorParts = selector.split(":");
-  if (selectorParts.length > 2) {
-    throw new Error(`Invalid connection selection "${value}".`);
-  }
-  const [connectorId, rawConnectionType] = selectorParts;
-  if (!connectorId) throw new Error(`Invalid connection selection "${value}".`);
-  if (rawConnectionType && rawConnectionType !== "mcp" && rawConnectionType !== "trigger") {
-    throw new Error(`Invalid connection type "${rawConnectionType}".`);
-  }
-  const connectionType = rawConnectionType === "mcp" || rawConnectionType === "trigger" ? rawConnectionType : void 0;
-  return {
-    connectorId,
-    connectionType,
-    connectionId
-  };
-}
 
 // src/commands/chat/index.ts
 function registerChatCommand(program) {
@@ -35597,7 +36122,7 @@ function registerChatCommand(program) {
   chat.command("continue").description("Continue a persisted conversation").argument("<conversation-id>", "Conversation ID emitted by start").argument("[message...]", "Answer or follow-up message").option(
     "--connection <connector[:type]=connection-id>",
     "Resolve a pending connection selection; repeat for multiple connectors",
-    collect,
+    collectOption,
     []
   ).action(
     async (conversationId, messageParts, options, command) => {
@@ -35680,9 +36205,6 @@ async function runCommand(command, operation) {
     }
   });
 }
-function collect(value, previous) {
-  return [...previous, value];
-}
 
 // src/commands/conversation/index.ts
 import { Option as Option3 } from "commander";
@@ -35815,6 +36337,13 @@ async function* streamConnectorNdjsonItems(api, options, signal) {
   }
   yield { _meta: true, connectionsIncluded: options.connections };
 }
+async function findListedConnector(api, connectorId, signal) {
+  for await (const page of iterateConnectorPages(api, void 0, { signal })) {
+    const connector = page.data.find((candidate) => candidate.id === connectorId);
+    if (connector) return connector;
+  }
+  return void 0;
+}
 function findConnector2(api, connectorId, signal) {
   return findConnector(api, connectorId, { signal });
 }
@@ -35842,6 +36371,8 @@ async function runAuthorizationCommand(command, operation) {
       return operation({
         api,
         signal,
+        output: output2,
+        openBrowser: options.open,
         authorizer: new ApiConnectionAuthorizer({
           connections: api.connections,
           output: output2,
@@ -35931,17 +36462,172 @@ function summarizeAffectedAutomation(automation) {
   };
 }
 
+// src/commands/connector/local-oauth-connect.ts
+import { createDcrProvider, runOAuthFlow } from "@doist/cli-core/auth";
+var PREFERRED_CALLBACK_PORT = 24369;
+async function connectViaLocalOAuth({
+  api,
+  connector,
+  capability,
+  repairConnectionId,
+  output: output2,
+  openBrowser,
+  signal
+}) {
+  const setup = await api.connections.getLocalOAuthSetup(
+    { connectorId: connector.id, capability },
+    { signal }
+  );
+  const { registrationEndpoint } = setup;
+  if (!registrationEndpoint) {
+    throw new Error(
+      `${connector.name} does not support dynamic client registration, so the CLI cannot connect it.`
+    );
+  }
+  const grant = await runLoopbackGrant({
+    connector,
+    capability,
+    setup,
+    registrationEndpoint,
+    output: output2,
+    openBrowser,
+    signal
+  });
+  const created = await api.connections.importLocalOAuth(
+    {
+      connectorId: connector.id,
+      capability,
+      grant: {
+        clientId: grant.account.clientId,
+        accessToken: grant.bundle.accessToken,
+        refreshToken: grant.bundle.refreshToken,
+        expiresIn: expiresInSeconds(grant.bundle.accessTokenExpiresAt),
+        ...repairConnectionId ? { repairConnectionId } : {}
+      }
+    },
+    { signal }
+  );
+  output2.emit({
+    type: "connection_authorized",
+    connectionId: created.connectionId,
+    connectorId: connector.id,
+    serviceName: connector.name,
+    connectionType: capability,
+    state: "completed",
+    terminal: false
+  });
+  return created.connectionId;
+}
+async function runLoopbackGrant({
+  connector,
+  capability,
+  setup,
+  registrationEndpoint,
+  output: output2,
+  openBrowser,
+  signal
+}) {
+  const retryHint = `Try again: ${connectViaCliCommand(connector.id, capability)}`;
+  const provider = createDcrProvider({
+    registrationUrl: registrationEndpoint,
+    authorizeUrl: setup.authorizationEndpoint,
+    tokenUrl: setup.tokenEndpoint,
+    resource: setup.resource ?? void 0,
+    clientMetadata: {
+      clientName: AUTOMATIONS_CLI_CLIENT_NAME,
+      logoUri: AUTOMATIONS_CLI_LOGO_URL,
+      applicationType: "native",
+      // The backend refreshes with the client id alone, so the client
+      // must be public: no secret to copy across.
+      tokenEndpointAuthMethod: "none",
+      grantTypes: ["authorization_code", "refresh_token"]
+    },
+    // The grant is handed to the backend as-is; here the "account" only
+    // carries the client id the server bound it to.
+    validate: async ({ handshake }) => ({
+      id: connector.id,
+      label: connector.name,
+      clientId: requireClientId(handshake)
+    }),
+    errorHints: [retryHint]
+  });
+  let captured;
+  const store2 = {
+    active: async () => null,
+    set: async () => {
+    },
+    setBundle: async (account, bundle) => {
+      captured = { account, bundle };
+    },
+    clear: async () => null,
+    list: async () => [],
+    setDefault: async () => {
+    }
+  };
+  await runOAuthFlow({
+    provider,
+    store: store2,
+    scopes: setup.scopes,
+    readOnly: false,
+    flags: {},
+    preferredPort: PREFERRED_CALLBACK_PORT,
+    renderSuccess: renderAuthSuccessPage,
+    renderError: renderAuthErrorPage,
+    ...openBrowser ? {} : { openBrowser: async () => {
+    } },
+    onAuthorizeUrl: (url2) => {
+      output2.emit({
+        type: "connection_authorization_started",
+        connectorId: connector.id,
+        serviceName: connector.name,
+        connectionType: capability,
+        state: "waiting_for_user",
+        terminal: false,
+        setupKind: "oauth",
+        authorizationUrl: url2
+      });
+    },
+    timeoutMs: CONNECTION_AUTHORIZATION_TIMEOUT_MS,
+    signal
+  });
+  if (!captured) {
+    throw new Error(`${connector.name} sign-in finished without a token. ${retryHint}`);
+  }
+  return captured;
+}
+function requireClientId(handshake) {
+  const clientId = handshake.clientId;
+  if (typeof clientId !== "string" || clientId.length === 0) {
+    throw new Error("The authorization server did not return a client id.");
+  }
+  return clientId;
+}
+function expiresInSeconds(expiresAt) {
+  if (expiresAt === void 0) return void 0;
+  const seconds = Math.floor((expiresAt - Date.now()) / 1e3);
+  return seconds > 0 ? seconds : void 0;
+}
+
 // src/commands/connector/mutation-commands.ts
 function registerConnectorMutationCommands(connector) {
   connector.command("connect").description("Create a service connection and wait for authorization").argument("<connector-id>", "Connector ID").addOption(
     new Option4("--capability <capability>", "Capability to authorize").choices(["mcp", "trigger"]).makeOptionMandatory()
   ).action(async (connectorId, options, command) => {
-    await runAuthorizationCommand(command, async ({ api, authorizer, signal }) => {
+    await runAuthorizationCommand(command, async (context) => {
+      const { api, authorizer, signal } = context;
       const selected2 = await findConnector2(api, connectorId, signal);
       assertConnectorSupportsCapability(selected2, options.capability);
       if (!selected2.requiresConnection) {
         throw new Error(`${selected2.name} does not require a connection.`);
       }
+      if (selected2.connectsViaCli) {
+        const connectionId2 = await connectViaLocalOAuth({
+          ...context,
+          connector: selected2,
+          capability: options.capability
+        });
+        return { action: "connected", connectionId: connectionId2 };
+      }
       const connectionId = await authorizer.authorize(
         {
           connectorId: selected2.id,
@@ -35978,7 +36664,8 @@ function registerConnectorMutationCommands(connector) {
     });
   });
   connector.command("repair").description("Start a replacement setup for a broken or expired connection").argument("<connection-id>", "Connection ID").action(async (connectionId, _options, command) => {
-    await runAuthorizationCommand(command, async ({ api, authorizer, signal }) => {
+    await runAuthorizationCommand(command, async (context) => {
+      const { api, authorizer, signal } = context;
       const connection = await api.connections.get(connectionId, { signal });
       if (connection.status === "authorized") {
         throw new Error(`Connection ${connectionId} is already authorized.`);
@@ -35992,7 +36679,19 @@ function registerConnectorMutationCommands(connector) {
         await authorizer.resume(request2, connection.id, connection.setup, signal);
         return { action: "connected", connectionId };
       }
-      const affectedAutomations = await findAffectedAutomations(api, connectionId, signal);
+      const [selected2, affectedAutomations] = await Promise.all([
+        findListedConnector(api, connection.connectorId, signal),
+        findAffectedAutomations(api, connectionId, signal)
+      ]);
+      if (selected2?.connectsViaCli) {
+        const repairedConnectionId2 = await connectViaLocalOAuth({
+          ...context,
+          connector: selected2,
+          capability: request2.connectionType,
+          repairConnectionId: connection.id
+        });
+        return { action: "connected", connectionId: repairedConnectionId2 };
+      }
       const repairedConnectionId = await authorizer.authorize(
         {
           ...request2,
@@ -36077,6 +36776,343 @@ function registerConnectorCommand(program) {
   registerConnectorMutationCommands(connector);
 }
 
+// src/lib/manifest-input.ts
+import { CliError as CliError3, getErrorMessage as getErrorMessage6 } from "@doist/cli-core";
+import { Option as Option6 } from "commander";
+import { readFile as readFile2 } from "node:fs/promises";
+import { text } from "node:stream/consumers";
+function addManifestInputOptions(command) {
+  return command.addOption(
+    new Option6("--file <path>", "Read the manifest from this JSON file").conflicts("stdin")
+  ).option("--stdin", "Read the manifest as JSON from standard input");
+}
+async function readManifestInput(options, input2 = process.stdin) {
+  const source = await readSource(options, input2);
+  try {
+    return JSON.parse(source.content);
+  } catch (error62) {
+    throw new CliError3(
+      "MANIFEST_UNREADABLE",
+      `${source.label} is not valid JSON: ${getErrorMessage6(error62)}`
+    );
+  }
+}
+function parsePartialManifestInput(value) {
+  const validation = validatePartialManifest(value);
+  if (!validation.isValid) {
+    throw new CliError3(
+      "MANIFEST_INVALID",
+      `Manifest is invalid: ${validation.errors.join("; ")}`
+    );
+  }
+  return validation.data;
+}
+async function readSource(options, input2) {
+  if (options.file !== void 0) {
+    try {
+      return { label: options.file, content: await readFile2(options.file, "utf8") };
+    } catch (error62) {
+      throw new CliError3(
+        "MANIFEST_UNREADABLE",
+        `Could not read ${options.file}: ${getErrorMessage6(error62)}`
+      );
+    }
+  }
+  if (options.stdin) {
+    try {
+      return { label: "Standard input", content: await text(input2) };
+    } catch (error62) {
+      throw new CliError3(
+        "MANIFEST_UNREADABLE",
+        `Could not read standard input: ${getErrorMessage6(error62)}`
+      );
+    }
+  }
+  throw new CliError3("MANIFEST_UNREADABLE", "Provide the manifest with --file <path> or --stdin.");
+}
+
+// src/commands/draft/draft-service.ts
+import { CliError as CliError4, getErrorMessage as getErrorMessage7 } from "@doist/cli-core";
+
+// src/lib/manifest-diff.ts
+function stableStringify(value) {
+  return JSON.stringify(sortKeys(value));
+}
+function isDeepEqual(left, right) {
+  return stableStringify(left) === stableStringify(right);
+}
+function diffManifests(before, after) {
+  const previous = asManifest(before);
+  const next = asManifest(after);
+  const changedProperties = [.../* @__PURE__ */ new Set([...Object.keys(previous), ...Object.keys(next)])].filter((key) => key !== "steps").filter((key) => !isDeepEqual(previous[key], next[key])).sort();
+  const previousSteps = stepsById(previous.steps);
+  const nextSteps = stepsById(next.steps);
+  const added = [...nextSteps.keys()].filter((id) => !previousSteps.has(id));
+  const removed = [...previousSteps.keys()].filter((id) => !nextSteps.has(id));
+  const changed = [...nextSteps].filter(([id, step]) => previousSteps.has(id) && !isDeepEqual(previousSteps.get(id), step)).map(([id]) => id);
+  const sharedBefore = [...previousSteps.keys()].filter((id) => nextSteps.has(id));
+  const sharedAfter = [...nextSteps.keys()].filter((id) => previousSteps.has(id));
+  const reordered = sharedBefore.some((id, index) => sharedAfter[index] !== id);
+  return {
+    changedProperties,
+    steps: { added, removed, changed, reordered },
+    isEmpty: changedProperties.length === 0 && added.length === 0 && removed.length === 0 && changed.length === 0 && !reordered
+  };
+}
+function asManifest(value) {
+  return isRecord3(value) ? value : {};
+}
+function stepsById(steps) {
+  const byId = /* @__PURE__ */ new Map();
+  if (!Array.isArray(steps)) return byId;
+  steps.forEach((step, index) => {
+    const id = isRecord3(step) && typeof step.id === "string" ? step.id : `#${index}`;
+    byId.set(id, step);
+  });
+  return byId;
+}
+function sortKeys(value) {
+  if (Array.isArray(value)) return value.map(sortKeys);
+  if (!isRecord3(value)) return value;
+  return Object.fromEntries(
+    Object.keys(value).sort().map((key) => [key, sortKeys(value[key])])
+  );
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/commands/draft/draft-service.ts
+function resolveDraftApi(api, workspaceId, signal) {
+  const createOptions = { signal, translate: false };
+  if (workspaceId === null) {
+    return {
+      scope: null,
+      get: (draftId) => api.automationDrafts.get(draftId, { signal }),
+      create: (manifest) => api.automationDrafts.create(manifest, createOptions),
+      update: (draftId, manifest) => api.automationDrafts.update(draftId, manifest, { signal }),
+      createAutomationDraft: (automationId) => api.automations.createDraft(automationId, { signal }),
+      upsertConnection: (draftId, body) => api.automationDraftConnections.upsert(draftId, body, { signal }),
+      getConnectionStatus: async (draftId) => (await api.automationDraftConnections.getStatus(draftId, { signal })).validation,
+      finalize: (draftId) => api.automationDrafts.finalize(draftId, { signal }),
+      getAutomation: (automationId) => api.automations.get(automationId, { signal })
+    };
+  }
+  return {
+    scope: workspaceId,
+    get: (draftId) => api.workspaceAutomationDrafts.get(workspaceId, draftId, { signal }),
+    create: (manifest) => api.workspaceAutomationDrafts.create(workspaceId, manifest, createOptions),
+    update: (draftId, manifest) => api.workspaceAutomationDrafts.update(workspaceId, draftId, manifest, { signal }),
+    createAutomationDraft: (automationId) => api.workspaceAutomations.createDraft(workspaceId, automationId, { signal }),
+    upsertConnection: (draftId, body) => api.workspaceAutomationDraftConnections.upsert(workspaceId, draftId, body, { signal }),
+    getConnectionStatus: async (draftId) => (await api.workspaceAutomationDraftConnections.getStatus(workspaceId, draftId, {
+      signal
+    })).validation,
+    finalize: (draftId) => api.workspaceAutomationDrafts.finalize(workspaceId, draftId, { signal }),
+    getAutomation: (automationId) => api.workspaceAutomations.get(workspaceId, automationId, { signal })
+  };
+}
+async function createDraft(draftApi, { manifest, automationId }) {
+  const partialManifest = parsePartialManifestInput(manifest);
+  if (automationId === void 0) {
+    const result = await draftApi.create(partialManifest);
+    return { action: "created", target: toTarget(result.draft), ...result };
+  }
+  const { draft } = await openEditDraft(draftApi, automationId);
+  try {
+    const result = await draftApi.update(draft.id, partialManifest);
+    return { action: "created", target: toTarget(result.draft), ...result };
+  } catch (error62) {
+    if (!isManifestRejection(error62)) throw error62;
+    throw new CliError4(
+      "DRAFT_MANIFEST_REJECTED",
+      `Opened draft ${draft.id} for automation ${automationId}, but the manifest was rejected: ${getErrorMessage7(error62)}`,
+      { hints: draftHints(draftApi.scope, draft.id) }
+    );
+  }
+}
+function isManifestRejection(error62) {
+  return error62 instanceof AutomationsRequestError && (error62.httpStatusCode === 400 || error62.httpStatusCode === 422);
+}
+async function updateDraft(draftApi, { draftId, manifest }) {
+  const partialManifest = parsePartialManifestInput(manifest);
+  const result = await draftApi.update(draftId, partialManifest);
+  return { action: "updated", target: toTarget(result.draft), ...result };
+}
+async function openEditDraft(draftApi, automationId) {
+  try {
+    return await draftApi.createAutomationDraft(automationId);
+  } catch (error62) {
+    const conflict = getOpenDraftConflictError(error62);
+    if (!conflict) throw error62;
+    throw new CliError4(
+      "DRAFT_CONFLICT",
+      `Automation ${automationId} already has an open draft ${conflict.draftId}.`,
+      { hints: draftHints(draftApi.scope, conflict.draftId) }
+    );
+  }
+}
+function draftHints(scope, draftId) {
+  const scopeFlag = scope === null ? "--personal" : `--workspace ${scope}`;
+  return [
+    `Apply the file to it: tda draft update ${draftId} --file <path> ${scopeFlag}`,
+    `Or discard it first: tda draft delete ${draftId} --yes ${scopeFlag}`
+  ];
+}
+function toTarget(draft) {
+  return draft.automationId === null ? { kind: "new" } : { kind: "automation", automationId: draft.automationId };
+}
+async function connectDraft(draftApi, api, {
+  draftId,
+  selections,
+  auto
+}) {
+  const bound = [];
+  const required2 = selections.length > 0 ? getRequiredConnectorsFromManifest(
+    (await draftApi.get(draftId)).draft.partialManifest
+  ) : /* @__PURE__ */ new Map();
+  for (const selection of selections) {
+    const types = required2.get(selection.connectorId);
+    if (!types || selection.connectionType && !types.has(selection.connectionType)) {
+      const slot = selection.connectionType ? `${selection.connectorId} (${selection.connectionType})` : selection.connectorId;
+      throw new Error(
+        `Connector ${slot} is not used by draft ${draftId}. Required: ${describeRequired(required2)}.`
+      );
+    }
+    const connectionTypes = selection.connectionType ? [selection.connectionType] : [...types];
+    for (const connectionType of connectionTypes) {
+      await draftApi.upsertConnection(draftId, {
+        connectorId: selection.connectorId,
+        connectionType,
+        connectionId: selection.connectionId
+      });
+      bound.push({ ...selection, connectionType, mode: "explicit" });
+    }
+  }
+  const unresolved = [];
+  if (auto) {
+    const status = await draftApi.getConnectionStatus(draftId);
+    for (const connector of status.connectors) {
+      for (const connectionType of ["mcp", "trigger"]) {
+        const slot = connector[connectionType];
+        if (!slot.required || slot.status !== "missing") continue;
+        const { connections } = await api.connections.list({
+          connectorId: connector.id,
+          capability: connectionType,
+          status: "authorized"
+        });
+        const [only] = connections;
+        if (connections.length === 1 && only) {
+          await draftApi.upsertConnection(draftId, {
+            connectorId: connector.id,
+            connectionType,
+            connectionId: only.id
+          });
+          bound.push({
+            connectorId: connector.id,
+            connectionType,
+            connectionId: only.id,
+            mode: "auto"
+          });
+          continue;
+        }
+        unresolved.push({
+          connectorId: connector.id,
+          connectionType,
+          reason: connections.length === 0 ? "no_connection" : "multiple_connections",
+          candidateConnectionIds: connections.map((connection) => connection.id)
+        });
+      }
+    }
+  }
+  const { isValid, missing } = await draftApi.getConnectionStatus(draftId);
+  return { action: "connected", draftId, bound, unresolved, isValid, missing };
+}
+function describeRequired(required2) {
+  if (required2.size === 0) return "none";
+  return [...required2].map(([connectorId, types]) => `${connectorId} (${[...types].join(", ")})`).join(", ");
+}
+async function publishDraft(draftApi, { draftId, confirmed }) {
+  const { summary, manifest } = await summarizeForPublish(draftApi, draftId);
+  if (!confirmed) {
+    return { action: "publish_preview", summary };
+  }
+  let published;
+  try {
+    published = await draftApi.finalize(draftId);
+  } catch (error62) {
+    const notReady = getDraftNotReadyError(error62);
+    if (!notReady) throw error62;
+    throw new CliError4("DRAFT_NOT_READY", notReady.message, {
+      hints: [
+        `See the issues: tda draft view ${draftId}`,
+        `Bind connections: tda draft connect ${draftId} --auto`
+      ]
+    });
+  }
+  const automation = await draftApi.getAutomation(published.automation.id);
+  const expected = normaliseManifest(manifest);
+  const actual = normaliseManifest(automation.manifest);
+  const verified = isDeepEqual(expected, actual);
+  return {
+    action: "published",
+    summary,
+    automation,
+    verified,
+    mismatch: verified ? null : diffManifests(expected, actual)
+  };
+}
+async function summarizeForPublish(draftApi, draftId) {
+  const [detail, connections] = await Promise.all([
+    draftApi.get(draftId),
+    draftApi.getConnectionStatus(draftId)
+  ]);
+  const { draft } = detail;
+  const target = toTarget(draft);
+  const published = target.kind === "automation" ? await draftApi.getAutomation(target.automationId) : null;
+  const diff = published ? diffManifests(
+    normaliseManifest(published.manifest),
+    normaliseManifest(draft.partialManifest)
+  ) : null;
+  const summary = {
+    draftId,
+    name: getResourceName(draft.partialManifest),
+    scope: draft.workspaceId === null ? { kind: "personal" } : {
+      kind: "workspace",
+      workspaceId: draft.workspaceId,
+      // A new workspace automation publishes team-visible; an
+      // edit keeps whatever the automation already has.
+      visibility: published?.visibility ?? "workspace"
+    },
+    target,
+    validation: { state: detail.state, issues: detail.issues },
+    connections: {
+      isValid: connections.isValid,
+      connected: connections.connected.map(
+        ({ connectorId, connectionType, connectionId }) => ({
+          connectorId,
+          connectionType,
+          connectionId
+        })
+      ),
+      missing: connections.missing
+    },
+    schedule: describeSchedule(draft.partialManifest),
+    diff
+  };
+  return { summary, manifest: draft.partialManifest };
+}
+function describeSchedule(manifest) {
+  if (!hasTriggerType(manifest)) return null;
+  const schedule = getManifestTriggers(manifest).find((trigger) => trigger.type === "schedule");
+  if (!schedule || schedule.type !== "schedule") return null;
+  return getScheduleTriggerDescription({ value: schedule.value, timeFormat: "24h" });
+}
+function normaliseManifest(manifest) {
+  const parsed = manifestSchema.safeParse(manifest);
+  return parsed.success ? parsed.data : manifest;
+}
+
 // src/commands/draft/format.ts
 function formatDraftDelete(result) {
   if (result.action === "delete_preview") {
@@ -36088,10 +37124,144 @@ function formatDraftDelete(result) {
   }
   return `Deleted draft ${result.draftId}.`;
 }
+function formatDraftChange(result) {
+  const verb = result.action === "created" ? "Created" : "Updated";
+  const target = result.target.kind === "new" ? "for a new automation" : `to update automation ${result.target.automationId}`;
+  return [
+    `${verb} draft ${result.draft.id} ${target}.`,
+    `Validation: ${result.state}`,
+    `Issues: ${result.issues.length > 0 ? result.issues.join("; ") : "none"}`
+  ].join("\n");
+}
+function formatDraftConnect(result) {
+  const lines = [`Draft ${result.draftId} connections:`];
+  if (result.bound.length === 0) {
+    lines.push("  (nothing bound)");
+  }
+  for (const binding of result.bound) {
+    const how = binding.mode === "auto" ? "auto (only authorised connection)" : "explicit";
+    lines.push(
+      `  ${binding.connectorId}  ${binding.connectionType}  ${binding.connectionId}  ${how}`
+    );
+  }
+  if (result.unresolved.length > 0) {
+    lines.push("Unresolved:");
+    for (const slot of result.unresolved) {
+      lines.push(
+        slot.reason === "no_connection" ? `  ${slot.connectorId}  ${slot.connectionType}  no authorised connection; run: tda connector connect ${slot.connectorId} --capability ${slot.connectionType}` : `  ${slot.connectorId}  ${slot.connectionType}  ${slot.candidateConnectionIds.length} authorised connections; pick one: --connection ${slot.connectorId}:${slot.connectionType}=<connection-id> (${slot.candidateConnectionIds.join(", ")})`
+      );
+    }
+  }
+  lines.push(
+    result.isValid ? "Connections: ready" : `Connections: missing ${result.missing.map((entry) => `${entry.connectorName} ${entry.connectionType} (${entry.reason})`).join(", ")}`
+  );
+  return lines.join("\n");
+}
+function formatDraftPublish(result) {
+  if (result.action === "publish_preview") {
+    return [...describePublishSummary(result.summary), "Use --yes to publish."].join("\n");
+  }
+  const { summary, automation } = result;
+  const how = summary.target.kind === "new" ? "new automation" : "updated";
+  return [
+    `Published draft ${summary.draftId} as automation ${automation.id} (${how}).`,
+    result.verified ? "Verified: published manifest matches the draft." : `Warning: published manifest differs from the draft: ${describeDiff(result.mismatch)}.`
+  ].join("\n");
+}
+function summarizeDraftPublish(result) {
+  if (result.action === "publish_preview") return result;
+  return { ...result, automation: summarizeAutomation(result.automation) };
+}
+function describePublishSummary(summary) {
+  const lines = [
+    `Draft: ${summary.name} (${summary.draftId})`,
+    summary.scope.kind === "personal" ? "Scope: personal" : `Scope: workspace ${summary.scope.workspaceId} (${describeVisibility2(summary)})`,
+    summary.target.kind === "new" ? "Action: create a new automation" : `Action: update automation ${summary.target.automationId}`,
+    summary.validation.issues.length === 0 ? `Validation: ${summary.validation.state}` : `Validation: ${summary.validation.state}; ${summary.validation.issues.join("; ")}`,
+    summary.connections.isValid ? "Connections: ready" : `Connections: missing ${summary.connections.missing.map((entry) => `${entry.connectorName} ${entry.connectionType} (${entry.reason})`).join(", ")}`,
+    `Schedule: ${summary.schedule ?? "none (runs on its trigger)"}`
+  ];
+  if (summary.diff) {
+    lines.push(
+      summary.diff.isEmpty ? "Changes vs published automation: none" : `Changes vs published automation: ${describeDiff(summary.diff)}`
+    );
+  }
+  return lines;
+}
+function describeVisibility2(summary) {
+  if (summary.scope.kind !== "workspace") return "";
+  const visibility = summary.scope.visibility === "workspace" ? "visible to the workspace" : "private";
+  return summary.target.kind === "new" ? `publishes ${visibility}` : `stays ${visibility}`;
+}
+function describeDiff(diff) {
+  if (!diff || diff.isEmpty) return "none";
+  const parts = [];
+  if (diff.changedProperties.length > 0) {
+    parts.push(`properties ${diff.changedProperties.join(", ")}`);
+  }
+  if (diff.steps.added.length > 0) parts.push(`steps added ${diff.steps.added.join(", ")}`);
+  if (diff.steps.removed.length > 0) parts.push(`steps removed ${diff.steps.removed.join(", ")}`);
+  if (diff.steps.changed.length > 0) parts.push(`steps changed ${diff.steps.changed.join(", ")}`);
+  if (diff.steps.reordered) parts.push("steps reordered");
+  return parts.join("; ");
+}
+
+// src/commands/draft/validate-command.ts
+import { CliError as CliError5 } from "@doist/cli-core";
+
+// src/lib/local-command.ts
+async function runLocalCommand(command, operation, presentation, execution = {}) {
+  let mode = "human";
+  try {
+    mode = getOutputMode(getGlobalOptions(command));
+    const result = await withSpinner({ text: execution.spinner ?? "Loading..." }, operation);
+    stopEarlySpinner();
+    writeResult(mode, result, presentation);
+  } catch (error62) {
+    writeFailure(mode, "error", renderFailure(error62, { mode }));
+    process.exitCode = 1;
+  }
+}
+
+// src/commands/draft/validate-command.ts
+function registerDraftValidateCommand(draft) {
+  addManifestInputOptions(
+    draft.command("validate").description("Check a manifest file against the full manifest schema, offline")
+  ).action(async (options, command) => {
+    await runLocalCommand(
+      command,
+      async () => validateManifestInput(await readManifestInput(options)),
+      { human: formatManifestValidation },
+      { spinner: "Validating manifest..." }
+    );
+  });
+}
+function validateManifestInput(manifest) {
+  const validation = validateManifest(manifest);
+  if (!validation.isValid) {
+    throw new CliError5(
+      "MANIFEST_INVALID",
+      `Manifest is invalid: ${validation.errors.join("; ")}`
+    );
+  }
+  const parsed = manifestSchema.parse(manifest);
+  return {
+    action: "validated",
+    name: parsed.name,
+    steps: parsed.steps.length,
+    triggers: getManifestTriggers(parsed).map((trigger) => trigger.type)
+  };
+}
+function formatManifestValidation(result) {
+  const steps = `${result.steps} step${result.steps === 1 ? "" : "s"}`;
+  const triggers = result.triggers.length === 0 ? "no triggers" : `trigger ${result.triggers.join(", ")}`;
+  return `Manifest "${result.name}" is valid: ${steps}, ${triggers}.`;
+}
 
 // src/commands/draft/index.ts
 function registerDraftCommand(program) {
-  const draft = program.command("draft").description("Inspect and delete automation drafts");
+  const draft = program.command("draft").description("Author and inspect automation drafts");
+  registerDraftValidateCommand(draft);
   addWorkspaceScopeOptions(
     addCursorPaginationOptions(
       draft.command("list").description("List drafts").option(
@@ -36135,6 +37305,85 @@ function registerDraftCommand(program) {
       { spinner: "Loading draft..." }
     );
   });
+  addWorkspaceScopeOptions(
+    addManifestInputOptions(
+      draft.command("create").description("Create a draft from a manifest file").option(
+        "--automation <automation-id>",
+        "Open an edit draft for this automation and apply the manifest to it"
+      )
+    )
+  ).action(async (options, command) => {
+    await runApiCommand(
+      command,
+      async ({ api, signal }) => {
+        const manifest = await readManifestInput(options);
+        const draftApi = resolveDraftApi(api, await resolveWorkspaceScope(options), signal);
+        return createDraft(draftApi, { manifest, automationId: options.automation });
+      },
+      { human: formatDraftChange },
+      { spinner: "Creating draft..." }
+    );
+  });
+  addWorkspaceScopeOptions(
+    addManifestInputOptions(
+      draft.command("update").description("Replace a draft's manifest with a manifest file").argument("<draft-id>", "Draft ID")
+    )
+  ).action(async (draftId, options, command) => {
+    await runApiCommand(
+      command,
+      async ({ api, signal }) => {
+        const manifest = await readManifestInput(options);
+        const draftApi = resolveDraftApi(api, await resolveWorkspaceScope(options), signal);
+        return updateDraft(draftApi, { draftId, manifest });
+      },
+      { human: formatDraftChange },
+      { spinner: "Updating draft..." }
+    );
+  });
+  addWorkspaceScopeOptions(
+    draft.command("connect").description("Bind the user's service connections to a draft").argument("<draft-id>", "Draft ID").option(
+      "--connection <connector[:type]=connection-id>",
+      "Bind this connection; repeat for multiple connectors",
+      collectOption,
+      []
+    ).option(
+      "--auto",
+      "Bind every remaining required connector that has exactly one authorised connection"
+    )
+  ).action(async (draftId, options, command) => {
+    await runApiCommand(
+      command,
+      async ({ api, signal }) => {
+        if (options.connection.length === 0 && options.auto !== true) {
+          throw new Error(
+            "Provide --connection connector[:type]=connection-id or --auto."
+          );
+        }
+        const selections = options.connection.map(parseConnectionSelectionOption);
+        const draftApi = resolveDraftApi(api, await resolveWorkspaceScope(options), signal);
+        return connectDraft(draftApi, api, {
+          draftId,
+          selections,
+          auto: options.auto === true
+        });
+      },
+      { human: formatDraftConnect },
+      { spinner: "Connecting..." }
+    );
+  });
+  addWorkspaceScopeOptions(
+    draft.command("publish").description("Publish a draft after previewing what it will do").argument("<draft-id>", "Draft ID").option("--yes", "Confirm publication")
+  ).action(async (draftId, options, command) => {
+    await runApiCommand(
+      command,
+      async ({ api, signal }) => {
+        const draftApi = resolveDraftApi(api, await resolveWorkspaceScope(options), signal);
+        return publishDraft(draftApi, { draftId, confirmed: options.yes === true });
+      },
+      { human: formatDraftPublish, json: summarizeDraftPublish },
+      { spinner: options.yes === true ? "Publishing..." : "Loading draft..." }
+    );
+  });
   addWorkspaceScopeOptions(
     draft.command("delete").description("Delete a draft after previewing which one it is").argument("<draft-id>", "Draft ID").option("--yes", "Confirm deletion")
   ).action(async (draftId, options, command) => {
@@ -36173,7 +37422,7 @@ function streamDraftList(options, fetchPage) {
 }
 
 // src/commands/run/index.ts
-import { Option as Option6 } from "commander";
+import { Option as Option7 } from "commander";
 function registerRunCommand(program) {
   const run = program.command("run").description("Inspect automation runs");
   addWorkspaceScopeOptions(
@@ -36181,7 +37430,7 @@ function registerRunCommand(program) {
       run.command("list").description("List runs for an automation").argument("<automation-id>", "Automation ID")
     )
   ).addOption(
-    new Option6("--status <status>", "Only show runs with this status").choices([
+    new Option7("--status <status>", "Only show runs with this status").choices([
       ...AUTOMATION_RUN_STATUSES
     ])
   ).option(
@@ -36265,26 +37514,12 @@ function registerRunCommand(program) {
   );
 }
 
-// src/lib/local-command.ts
-async function runLocalCommand(command, operation, presentation, execution = {}) {
-  let mode = "human";
-  try {
-    mode = getOutputMode(getGlobalOptions(command));
-    const result = await withSpinner({ text: execution.spinner ?? "Loading..." }, operation);
-    stopEarlySpinner();
-    writeResult(mode, result, presentation);
-  } catch (error62) {
-    writeFailure(mode, "error", renderFailure(error62, { mode }));
-    process.exitCode = 1;
-  }
-}
-
 // src/commands/skill/shared.ts
-import { CliError as CliError3 } from "@doist/cli-core";
+import { CliError as CliError6 } from "@doist/cli-core";
 function requireInstaller(agent) {
   const installer = getInstaller(agent);
   if (!installer) {
-    throw new CliError3("UNKNOWN_AGENT", `Unknown agent: ${agent}.`, {
+    throw new CliError6("UNKNOWN_AGENT", `Unknown agent: ${agent}.`, {
       hints: [`Available agents: ${AGENT_NAMES.join(", ")}.`]
     });
   }
@@ -36362,7 +37597,7 @@ async function uninstallSkill(agent, options, command) {
 }
 
 // src/commands/skill/update.ts
-import { CliError as CliError4 } from "@doist/cli-core";
+import { CliError as CliError7 } from "@doist/cli-core";
 async function updateSkill(agent, options, command) {
   await runLocalCommand(
     command,
@@ -36388,7 +37623,7 @@ async function updateAllSkills(options, command) {
     async () => {
       const result = await updateAllInstalledSkills(options.local === true);
       if (result.errors.length > 0) {
-        throw new CliError4(
+        throw new CliError7(
           "UPDATE_FAILED",
           `Could not update ${result.errors.length} skill file(s).`,
           { hints: result.errors.map((error62) => `${error62.agent}: ${error62.message}`) }
@@ -36549,13 +37784,13 @@ async function findWorkspace(api, workspaceId, signal) {
 // src/lib/command-output.ts
 function configureCommandOutput(command) {
   return command.configureOutput({
-    writeOut: (text) => {
+    writeOut: (text2) => {
       stopEarlySpinner();
-      process.stdout.write(text);
+      process.stdout.write(text2);
     },
-    writeErr: (text) => {
+    writeErr: (text2) => {
       stopEarlySpinner();
-      process.stderr.write(text);
+      process.stderr.write(text2);
     }
   });
 }
@@ -36567,7 +37802,7 @@ function createProgram() {
     `Target environment: ${ENVIRONMENT_NAMES.join(", ")}`,
     parseEnvironmentOption,
     initialEnvironmentName()
-  ).option("--api-url <url>", "Automations API base URL (overrides --env)").option("-H, --header <name:value>", "Additional API header", collect2, []).option("--json", "Emit one final JSON document").option("--ndjson", "Emit newline-delimited JSON").option("--no-interactive", "Complete one server turn and exit").option("--no-open", "Print connection setup URLs without opening a browser").option("--no-spinner", "Disable the loading spinner").showHelpAfterError();
+  ).option("--api-url <url>", "Automations API base URL (overrides --env)").option("-H, --header <name:value>", "Additional API header", collect, []).option("--json", "Emit one final JSON document").option("--ndjson", "Emit newline-delimited JSON").option("--no-interactive", "Complete one server turn and exit").option("--no-open", "Print connection setup URLs without opening a browser").option("--no-spinner", "Disable the loading spinner").showHelpAfterError();
   configureCommandOutput(program);
   registerAuthCommand(program);
   registerAutomationCommand(program);
@@ -36581,7 +37816,7 @@ function createProgram() {
   registerWorkspaceCommand(program);
   return program;
 }
-function collect2(value, previous) {
+function collect(value, previous) {
   return [...previous, value];
 }
 if (isEntrypoint()) {