@doist/automations-cli 1.8.0 → 1.9.0

package/dist/index.js

@@ -15,7 +15,7 @@ import { fileURLToPath } from "node:url";
 // package.json
 var package_default = {
   name: "@doist/automations-cli",
-  version: "1.8.0",
+  version: "1.9.0",
   description: "Command-line client for Todoist Automations",
   type: "module",
   bin: {
@@ -64,8 +64,7 @@ var package_default = {
     ai: "7.0.77",
     commander: "15.0.0",
     oauth4webapi: "3.8.8",
-    open: "11.0.2",
-    "p-limit": "3.1.0"
+    open: "11.0.3"
   },
   devDependencies: {
     "@doist/automations-core": "*",
@@ -1829,10 +1828,10 @@ function node(obj, key, make) {
   }
   return obj[key];
 }
-function flattenError(error61, mapper = (issue2) => issue2.message) {
+function flattenError(error62, mapper = (issue2) => issue2.message) {
   const fieldErrors = {};
   const formErrors = [];
-  for (const sub of error61.issues) {
+  for (const sub of error62.issues) {
     if (sub.path.length > 0) {
       node(fieldErrors, sub.path[0], () => []).push(mapper(sub));
     } else {
@@ -1841,10 +1840,10 @@ function flattenError(error61, mapper = (issue2) => issue2.message) {
   }
   return { formErrors, fieldErrors };
 }
-function formatError(error61, mapper = (issue2) => issue2.message) {
+function formatError(error62, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error62, path = []) => {
-    for (const issue2 of error62.issues) {
+  const processError = (error63, path = []) => {
+    for (const issue2 of error63.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
         issue2.errors.map((issues) => processError({ issues }, [...path, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
@@ -1886,14 +1885,14 @@ function formatError(error61, mapper = (issue2) => issue2.message) {
       }
     }
   };
-  processError(error61);
+  processError(error62);
   return fieldErrors;
 }
-function treeifyError(error61, mapper = (issue2) => issue2.message) {
+function treeifyError(error62, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error62, path = []) => {
+  const processError = (error63, path = []) => {
     var _a3;
-    for (const issue2 of error62.issues) {
+    for (const issue2 of error63.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
         issue2.errors.map((issues) => processError({ issues }, [...path, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
@@ -1935,7 +1934,7 @@ function treeifyError(error61, mapper = (issue2) => issue2.message) {
       }
     }
   };
-  processError(error61);
+  processError(error62);
   return result;
 }
 function toDotPath(_path) {
@@ -1956,9 +1955,9 @@ function toDotPath(_path) {
   }
   return segs.join("");
 }
-function prettifyError(error61) {
+function prettifyError(error62) {
   const lines = [];
-  const issues = [...error61.issues].sort((a, b) => (a.path ?? []).length - (b.path ?? []).length);
+  const issues = [...error62.issues].sort((a, b) => (a.path ?? []).length - (b.path ?? []).length);
   for (const issue2 of issues) {
     lines.push(`\u2716 ${issue2.message}`);
     if (issue2.path?.length)
@@ -2014,19 +2013,19 @@ var _safeParse = (_Err) => (schema, value, _ctx) => {
 };
 var safeParse = /* @__PURE__ */ _safeParse($ZodRealError);
 function failure(Err, issues, ctx) {
-  let error61;
+  let error62;
   return {
     success: false,
     get error() {
-      if (!error61) {
-        error61 = new Err(issues.map((iss) => finalizeIssue(iss, ctx, config())));
+      if (!error62) {
+        error62 = new Err(issues.map((iss) => finalizeIssue(iss, ctx, config())));
         issues = void 0;
         ctx = void 0;
       }
-      return error61;
+      return error62;
     },
     set error(e) {
-      error61 = e;
+      error62 = e;
       issues = void 0;
       ctx = void 0;
     }
@@ -2790,7 +2789,7 @@ ${content.join("\n")}
 var version = {
   major: 4,
   minor: 6,
-  patch: 0
+  patch: 2
 };
 
 // ../../node_modules/zod/v4/core/schemas.js
@@ -3594,7 +3593,7 @@ function handlePropertyResult(result, final, key, input2, optin, optout) {
     return;
   }
   if (result.value === void 0) {
-    if (isPresent) {
+    if (isPresent || optin === "defaulted" && !isOptionalOut) {
       final.value[key] = void 0;
     }
   } else {
@@ -3830,16 +3829,16 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
         doc.write(`
         if (${id}.issues.length) {${prefixStr(id, k)}
         }
-        
-        if (${id}.value === undefined) {
-          if (${isPresent}) {
-            newResult[${k}] = undefined;
-          }
+      `);
+        if (optin === "defaulted") {
+          doc.write(`newResult[${k}] = ${id}.value;`);
         } else {
+          doc.write(`
+        if (${id}.value !== undefined || ${isPresent}) {
           newResult[${k}] = ${id}.value;
         }
-
       `);
+        }
       }
     }
     doc.write(`payload.value = newResult;`);
@@ -4003,16 +4002,31 @@ function getDiscriminatedOption(union2, value) {
   const internals = union2._zod;
   let map2 = internals.bag.optionsMap;
   if (!map2) {
-    map2 = /* @__PURE__ */ new Map();
-    const { options, discriminator } = internals.def;
-    for (const option of options) {
-      for (const v of option._zod.propValues?.[discriminator] ?? [])
-        if (!map2.has(v))
-          map2.set(v, option);
-    }
+    map2 = discriminatorMap(internals.def);
     internals.bag.optionsMap = map2;
   }
-  return map2.get(value);
+  const option = map2.get(value);
+  if (option === null)
+    throw new Error(`Ambiguous discriminator value "${String(value)}"`);
+  return option;
+}
+function discriminatorMap(def) {
+  const map2 = /* @__PURE__ */ new Map();
+  for (const option of def.options) {
+    const values = option._zod.propValues?.[def.discriminator];
+    if (!values || values.size === 0)
+      throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(option)}"`);
+    for (const value of values) {
+      if (map2.has(value)) {
+        if (value !== void 0)
+          throw new Error(`Duplicate discriminator value "${String(value)}"`);
+        map2.set(value, null);
+      } else {
+        map2.set(value, option);
+      }
+    }
+  }
+  return map2;
 }
 var $ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("$ZodDiscriminatedUnion", (inst, def) => {
   def.inclusive = false;
@@ -4020,10 +4034,13 @@ var $ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("$ZodDiscriminatedUnio
   const _super = inst._zod.parse;
   defineLazyInternal(inst, "propValues", (zod) => {
     const propValues = {};
+    let undefinedCount = 0;
     for (const option of zod.def.options) {
       const pv = option._zod.propValues;
       if (!pv || Object.keys(pv).length === 0)
         throw new Error(`Invalid discriminated union option at index "${zod.def.options.indexOf(option)}"`);
+      if (pv[zod.def.discriminator]?.has(void 0))
+        undefinedCount++;
       for (const [k, v] of Object.entries(pv)) {
         if (!Object.prototype.hasOwnProperty.call(propValues, k)) {
           assignProp(propValues, k, /* @__PURE__ */ new Set());
@@ -4033,6 +4050,8 @@ var $ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("$ZodDiscriminatedUnio
         }
       }
     }
+    if (!zod.def.unionFallback && undefinedCount > 1)
+      propValues[zod.def.discriminator]?.delete(void 0);
     return propValues;
   });
   def.options.forEach((option, i) => {
@@ -4041,22 +4060,7 @@ var $ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("$ZodDiscriminatedUnio
       throw new Error(`Invalid discriminated union option at index "${i}"`);
     }
   });
-  const disc = cached(() => {
-    const opts = def.options;
-    const map2 = /* @__PURE__ */ new Map();
-    for (const o of opts) {
-      const values = o._zod.propValues?.[def.discriminator];
-      if (!values || values.size === 0)
-        throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(o)}"`);
-      for (const v of values) {
-        if (map2.has(v)) {
-          throw new Error(`Duplicate discriminator value "${String(v)}"`);
-        }
-        map2.set(v, o);
-      }
-    }
-    return map2;
-  });
+  const disc = cached(() => discriminatorMap(def));
   inst._zod.parse = (payload, ctx) => {
     const input2 = payload.value;
     if (!isObject(input2)) {
@@ -4068,8 +4072,9 @@ var $ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("$ZodDiscriminatedUnio
       });
       return payload;
     }
-    const opt = disc.value.get(input2?.[def.discriminator]);
-    if (opt) {
+    const value = input2?.[def.discriminator];
+    const opt = disc.value.get(value);
+    if (opt && (value !== void 0 || ctx.direction !== "backward")) {
       return opt._zod.run(payload, ctx);
     }
     if (def.unionFallback || ctx.direction === "backward") {
@@ -4080,7 +4085,7 @@ var $ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("$ZodDiscriminatedUnio
       errors: [],
       note: "No matching discriminator",
       discriminator: def.discriminator,
-      options: Array.from(disc.value.keys()),
+      options: Array.from(disc.value.keys()).filter((value2) => disc.value.get(value2) !== null),
       input: input2,
       path: [def.discriminator],
       inst
@@ -5568,6 +5573,7 @@ __export(locales_exports, {
   sl: () => sl_default,
   sv: () => sv_default,
   ta: () => ta_default,
+  tg: () => tg_default,
   th: () => th_default,
   tk: () => tk_default,
   tr: () => tr_default,
@@ -11774,8 +11780,124 @@ function ta_default() {
   };
 }
 
-// ../../node_modules/zod/v4/locales/th.js
+// ../../node_modules/zod/v4/locales/tg.js
 var error51 = () => {
+  const Sizable = {
+    string: { unit: "\u0430\u043B\u043E\u043C\u0430\u0442", verb: "\u0434\u043E\u0448\u0442\u0430 \u0431\u043E\u0448\u0430\u0434" },
+    file: { unit: "\u0431\u0430\u0439\u0442", verb: "\u0434\u043E\u0448\u0442\u0430 \u0431\u043E\u0448\u0430\u0434" },
+    array: { unit: "\u0443\u043D\u0441\u0443\u0440", verb: "\u0434\u043E\u0448\u0442\u0430 \u0431\u043E\u0448\u0430\u0434" },
+    set: { unit: "\u0443\u043D\u0441\u0443\u0440", verb: "\u0434\u043E\u0448\u0442\u0430 \u0431\u043E\u0448\u0430\u0434" },
+    map: { unit: "\u0441\u0430\u0431\u0442", verb: "\u0434\u043E\u0448\u0442\u0430 \u0431\u043E\u0448\u0430\u0434" }
+  };
+  function getSizing(origin) {
+    return Sizable[origin] ?? null;
+  }
+  const FormatDictionary = {
+    regex: "\u0432\u0443\u0440\u0443\u0434",
+    email: "\u0441\u0443\u0440\u043E\u0493\u0430\u0438 email",
+    url: "URL",
+    emoji: "\u044D\u043C\u043E\u04B7\u0438",
+    uuid: "UUID",
+    uuidv4: "UUIDv4",
+    uuidv6: "UUIDv6",
+    nanoid: "nanoid",
+    guid: "GUID",
+    cuid: "cuid",
+    cuid2: "cuid2",
+    ulid: "ULID",
+    xid: "XID",
+    ksuid: "KSUID",
+    datetime: "\u0441\u0430\u043D\u0430\u0432\u0443 \u0432\u0430\u049B\u0442\u0438 ISO",
+    date: "\u0441\u0430\u043D\u0430\u0438 ISO",
+    time: "\u0432\u0430\u049B\u0442\u0438 ISO",
+    duration: "\u0434\u0430\u0432\u043E\u043C\u043D\u043E\u043A\u0438\u0438 ISO",
+    ipv4: "\u0441\u0443\u0440\u043E\u0493\u0430\u0438 IPv4",
+    ipv6: "\u0441\u0443\u0440\u043E\u0493\u0430\u0438 IPv6",
+    mac: "\u0441\u0443\u0440\u043E\u0493\u0430\u0438 MAC",
+    cidrv4: "\u043C\u0430\u04B3\u0434\u0443\u0434\u0430\u0438 IPv4",
+    cidrv6: "\u043C\u0430\u04B3\u0434\u0443\u0434\u0430\u0438 IPv6",
+    base64: "\u0441\u0430\u0442\u0440\u0438 \u0434\u0430\u0440 \u0444\u043E\u0440\u043C\u0430\u0442\u0438 base64",
+    base64url: "\u0441\u0430\u0442\u0440\u0438 \u0434\u0430\u0440 \u0444\u043E\u0440\u043C\u0430\u0442\u0438 base64url",
+    json_string: "\u0441\u0430\u0442\u0440\u0438 JSON",
+    e164: "\u0440\u0430\u049B\u0430\u043C\u0438 E.164",
+    credit_card: "\u0440\u0430\u049B\u0430\u043C\u0438 \u043A\u043E\u0440\u0442\u0438 \u043A\u0440\u0435\u0434\u0438\u0442\u04E3",
+    iban: "IBAN",
+    jwt: "JWT",
+    template_literal: "\u0432\u0443\u0440\u0443\u0434"
+  };
+  const TypeDictionary = {
+    nan: "NaN",
+    number: "\u0440\u0430\u049B\u0430\u043C",
+    string: "\u0441\u0430\u0442\u0440",
+    array: "\u043C\u0430\u0441\u0441\u0438\u0432",
+    object: "\u043E\u0431\u044A\u0435\u043A\u0442",
+    date: "\u0441\u0430\u043D\u0430"
+  };
+  return (issue2) => {
+    switch (issue2.code) {
+      case "invalid_type": {
+        const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+        const receivedType = parsedType(issue2.input);
+        const received = TypeDictionary[receivedType] ?? receivedType;
+        return `\u0412\u0443\u0440\u0443\u0434\u0438 \u043D\u043E\u0434\u0443\u0440\u0443\u0441\u0442: ${expected} \u0438\u043D\u0442\u0438\u0437\u043E\u0440 \u043C\u0435\u0440\u0430\u0444\u0442, ${received} \u0433\u0438\u0440\u0438\u0444\u0442\u0430 \u0448\u0443\u0434`;
+      }
+      case "invalid_value":
+        if (issue2.values.length === 1)
+          return `\u0412\u0443\u0440\u0443\u0434\u0438 \u043D\u043E\u0434\u0443\u0440\u0443\u0441\u0442: ${stringifyPrimitive(issue2.values[0])} \u0438\u043D\u0442\u0438\u0437\u043E\u0440 \u043C\u0435\u0440\u0430\u0444\u0442`;
+        return `\u0418\u043D\u0442\u0438\u0445\u043E\u0431\u0438 \u043D\u043E\u0434\u0443\u0440\u0443\u0441\u0442: \u044F\u043A\u0435 \u0430\u0437 ${joinValues(issue2.values, "|")} \u0438\u043D\u0442\u0438\u0437\u043E\u0440 \u043C\u0435\u0440\u0430\u0444\u0442`;
+      case "too_big": {
+        const adj = issue2.inclusive ? "<=" : "<";
+        const sizing = getSizing(issue2.origin);
+        if (sizing)
+          return `\u0425\u0435\u043B\u0435 \u043A\u0430\u043B\u043E\u043D: ${issue2.origin ?? "\u049B\u0438\u043C\u0430\u0442"} \u0431\u043E\u044F\u0434 ${adj}${issue2.maximum.toString()} ${sizing.unit} ${sizing.verb}`;
+        return `\u0425\u0435\u043B\u0435 \u043A\u0430\u043B\u043E\u043D: ${issue2.origin ?? "\u049B\u0438\u043C\u0430\u0442"} \u0431\u043E\u044F\u0434 ${adj}${issue2.maximum.toString()} \u0431\u043E\u0448\u0430\u0434`;
+      }
+      case "too_small": {
+        const adj = issue2.inclusive ? ">=" : ">";
+        const sizing = getSizing(issue2.origin);
+        if (sizing)
+          return `\u0425\u0435\u043B\u0435 \u0445\u0443\u0440\u0434: ${issue2.origin} \u0431\u043E\u044F\u0434 ${adj}${issue2.minimum.toString()} ${sizing.unit} ${sizing.verb}`;
+        return `\u0425\u0435\u043B\u0435 \u0445\u0443\u0440\u0434: ${issue2.origin} \u0431\u043E\u044F\u0434 ${adj}${issue2.minimum.toString()} \u0431\u043E\u0448\u0430\u0434`;
+      }
+      case "invalid_format": {
+        const _issue = issue2;
+        if (_issue.format === "starts_with")
+          return `\u0421\u0430\u0442\u0440\u0438 \u043D\u043E\u0434\u0443\u0440\u0443\u0441\u0442: \u0431\u043E\u044F\u0434 \u0431\u043E "${_issue.prefix}" \u043E\u0493\u043E\u0437 \u0448\u0430\u0432\u0430\u0434`;
+        if (_issue.format === "ends_with")
+          return `\u0421\u0430\u0442\u0440\u0438 \u043D\u043E\u0434\u0443\u0440\u0443\u0441\u0442: \u0431\u043E\u044F\u0434 \u0431\u043E "${_issue.suffix}" \u0430\u043D\u04B7\u043E\u043C \u0451\u0431\u0430\u0434`;
+        if (_issue.format === "includes")
+          return `\u0421\u0430\u0442\u0440\u0438 \u043D\u043E\u0434\u0443\u0440\u0443\u0441\u0442: \u0431\u043E\u044F\u0434 "${_issue.includes}"-\u0440\u043E \u0434\u0430\u0440 \u0431\u0430\u0440 \u0433\u0438\u0440\u0430\u0434`;
+        if (_issue.format === "regex")
+          return `\u0421\u0430\u0442\u0440\u0438 \u043D\u043E\u0434\u0443\u0440\u0443\u0441\u0442: \u0431\u043E\u044F\u0434 \u0431\u0430 \u043D\u0430\u043C\u0443\u043D\u0430\u0438 ${_issue.pattern} \u043C\u0443\u0432\u043E\u0444\u0438\u049B\u0430\u0442 \u043A\u0443\u043D\u0430\u0434`;
+        return `${FormatDictionary[_issue.format] ?? issue2.format}-\u0438 \u043D\u043E\u0434\u0443\u0440\u0443\u0441\u0442`;
+      }
+      case "not_multiple_of":
+        return `\u0420\u0430\u049B\u0430\u043C\u0438 \u043D\u043E\u0434\u0443\u0440\u0443\u0441\u0442: \u0431\u043E\u044F\u0434 \u0431\u0430 ${issue2.divisor} \u0431\u0435 \u0431\u0430\u049B\u0438\u044F \u0442\u0430\u049B\u0441\u0438\u043C \u0448\u0430\u0432\u0430\u0434`;
+      case "unrecognized_keys":
+        return `\u041A\u0430\u043B\u0438\u0434${issue2.keys.length > 1 ? "\u04B3\u043E\u0438" : "\u0438"} \u043D\u043E\u043C\u0430\u044A\u043B\u0443\u043C: ${joinValues(issue2.keys, ", ")}`;
+      case "invalid_key":
+        return `\u041A\u0430\u043B\u0438\u0434\u0438 \u043D\u043E\u0434\u0443\u0440\u0443\u0441\u0442 \u0434\u0430\u0440 ${issue2.origin}`;
+      case "invalid_union":
+        if (issue2.options && Array.isArray(issue2.options) && issue2.options.length > 0) {
+          const opts = issue2.options.map((o) => `'${o}'`).join(" | ");
+          return `\u049A\u0438\u043C\u0430\u0442\u0438 \u043D\u043E\u0434\u0443\u0440\u0443\u0441\u0442\u0438 \u0434\u0438\u0441\u043A\u0440\u0438\u043C\u0438\u043D\u0430\u0442\u043E\u0440: ${opts} \u0438\u043D\u0442\u0438\u0437\u043E\u0440 \u043C\u0435\u0440\u0430\u0444\u0442`;
+        }
+        return "\u0412\u0443\u0440\u0443\u0434\u0438 \u043D\u043E\u0434\u0443\u0440\u0443\u0441\u0442";
+      case "invalid_element":
+        return `\u049A\u0438\u043C\u0430\u0442\u0438 \u043D\u043E\u0434\u0443\u0440\u0443\u0441\u0442 \u0434\u0430\u0440 ${issue2.origin}`;
+      default:
+        return `\u0412\u0443\u0440\u0443\u0434\u0438 \u043D\u043E\u0434\u0443\u0440\u0443\u0441\u0442`;
+    }
+  };
+};
+function tg_default() {
+  return {
+    localeError: error51()
+  };
+}
+
+// ../../node_modules/zod/v4/locales/th.js
+var error52 = () => {
   const Sizable = {
     string: { unit: "\u0E15\u0E31\u0E27\u0E2D\u0E31\u0E01\u0E29\u0E23", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" },
     file: { unit: "\u0E44\u0E1A\u0E15\u0E4C", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" },
@@ -11885,12 +12007,12 @@ var error51 = () => {
 };
 function th_default() {
   return {
-    localeError: error51()
+    localeError: error52()
   };
 }
 
 // ../../node_modules/zod/v4/locales/tk.js
-var error52 = () => {
+var error53 = () => {
   const Sizable = {
     string: { unit: "simwol", verb: "bolmaly" },
     file: { unit: "ba\xFDt", verb: "bolmaly" },
@@ -11992,12 +12114,12 @@ var error52 = () => {
 };
 function tk_default() {
   return {
-    localeError: error52()
+    localeError: error53()
   };
 }
 
 // ../../node_modules/zod/v4/locales/tr.js
-var error53 = () => {
+var error54 = () => {
   const Sizable = {
     string: { unit: "karakter", verb: "olmal\u0131" },
     file: { unit: "bayt", verb: "olmal\u0131" },
@@ -12102,12 +12224,12 @@ var error53 = () => {
 };
 function tr_default() {
   return {
-    localeError: error53()
+    localeError: error54()
   };
 }
 
 // ../../node_modules/zod/v4/locales/uk.js
-var error54 = () => {
+var error55 = () => {
   const Sizable = {
     string: { unit: "\u0441\u0438\u043C\u0432\u043E\u043B\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" },
     file: { unit: "\u0431\u0430\u0439\u0442\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" },
@@ -12215,7 +12337,7 @@ var error54 = () => {
 };
 function uk_default() {
   return {
-    localeError: error54()
+    localeError: error55()
   };
 }
 
@@ -12225,7 +12347,7 @@ function ua_default() {
 }
 
 // ../../node_modules/zod/v4/locales/ur.js
-var error55 = () => {
+var error56 = () => {
   const Sizable = {
     string: { unit: "\u062D\u0631\u0648\u0641", verb: "\u06C1\u0648\u0646\u0627" },
     file: { unit: "\u0628\u0627\u0626\u0679\u0633", verb: "\u06C1\u0648\u0646\u0627" },
@@ -12335,12 +12457,12 @@ var error55 = () => {
 };
 function ur_default() {
   return {
-    localeError: error55()
+    localeError: error56()
   };
 }
 
 // ../../node_modules/zod/v4/locales/uz.js
-var error56 = () => {
+var error57 = () => {
   const Sizable = {
     string: { unit: "belgi", verb: "bo\u2018lishi kerak" },
     file: { unit: "bayt", verb: "bo\u2018lishi kerak" },
@@ -12448,12 +12570,12 @@ var error56 = () => {
 };
 function uz_default() {
   return {
-    localeError: error56()
+    localeError: error57()
   };
 }
 
 // ../../node_modules/zod/v4/locales/vi.js
-var error57 = () => {
+var error58 = () => {
   const Sizable = {
     string: { unit: "k\xFD t\u1EF1", verb: "c\xF3" },
     file: { unit: "byte", verb: "c\xF3" },
@@ -12561,12 +12683,12 @@ var error57 = () => {
 };
 function vi_default() {
   return {
-    localeError: error57()
+    localeError: error58()
   };
 }
 
 // ../../node_modules/zod/v4/locales/zh-CN.js
-var error58 = () => {
+var error59 = () => {
   const Sizable = {
     string: { unit: "\u5B57\u7B26", verb: "\u5305\u542B" },
     file: { unit: "\u5B57\u8282", verb: "\u5305\u542B" },
@@ -12675,12 +12797,12 @@ var error58 = () => {
 };
 function zh_CN_default() {
   return {
-    localeError: error58()
+    localeError: error59()
   };
 }
 
 // ../../node_modules/zod/v4/locales/zh-TW.js
-var error59 = () => {
+var error60 = () => {
   const Sizable = {
     string: { unit: "\u5B57\u5143", verb: "\u64C1\u6709" },
     file: { unit: "\u4F4D\u5143\u7D44", verb: "\u64C1\u6709" },
@@ -12787,12 +12909,12 @@ var error59 = () => {
 };
 function zh_TW_default() {
   return {
-    localeError: error59()
+    localeError: error60()
   };
 }
 
 // ../../node_modules/zod/v4/locales/yo.js
-var error60 = () => {
+var error61 = () => {
   const Sizable = {
     string: { unit: "\xE0mi", verb: "n\xED" },
     file: { unit: "bytes", verb: "n\xED" },
@@ -12899,7 +13021,7 @@ var error60 = () => {
 };
 function yo_default() {
   return {
-    localeError: error60()
+    localeError: error61()
   };
 }
 
@@ -13776,7 +13898,7 @@ function generateObjectCheck(doc, ctx, schema, accessor, buildsValue = true) {
     }
   }
   const outputVar = newVar(ctx);
-  const hasConditionalKeys = allKeys.some((k) => mayOutputUndefined(propShape[k]) || dropsWhenAbsent(propShape[k]));
+  const hasConditionalKeys = allKeys.some((k) => mayOmitUndefined(propShape[k]) || dropsWhenAbsent(propShape[k]));
   if (!buildsValue) {
     if (unknownKeysMode === "schema") {
       const knownSet = keys.length > 0 ? addConstant(ctx, new Set(keys)) : null;
@@ -13803,7 +13925,7 @@ function generateObjectCheck(doc, ctx, schema, accessor, buildsValue = true) {
       const out = propOutputs.get(k);
       if (dropsWhenAbsent(propShape[k])) {
         doc.write(`if (${kx} in ${accessor}) ${outputVar}[${kx}] = ${out};`);
-      } else if (mayOutputUndefined(propShape[k])) {
+      } else if (mayOmitUndefined(propShape[k])) {
         doc.write(`if (${out} !== undefined || ${kx} in ${accessor}) ${outputVar}[${kx}] = ${out};`);
       } else {
         doc.write(`${outputVar}[${kx}] = ${out};`);
@@ -13936,6 +14058,9 @@ function fastPathAcceptsAbsence(schema) {
 function dropsWhenAbsent(schema) {
   return schema._zod.optin === "optional" && schema._zod.optout === "optional";
 }
+function mayOmitUndefined(schema) {
+  return (schema._zod.optin !== "defaulted" || schema._zod.optout === "optional") && mayOutputUndefined(schema);
+}
 function mayOutputUndefined(schema) {
   const def = schema._zod.def;
   switch (def.type) {
@@ -20053,9 +20178,9 @@ function summarizeToolCallResult(toolName, payload) {
   }
   return { outcome, preview: summarizeToolCallPayloadPreview(payload) };
 }
-function classifyToolCallOutcome(toolName, result, error61, errorDetails = {}) {
-  if (error61 !== void 0) {
-    return { outcome: "error", errorCategory: classifyToolCallError(error61, errorDetails) };
+function classifyToolCallOutcome(toolName, result, error62, errorDetails = {}) {
+  if (error62 !== void 0) {
+    return { outcome: "error", errorCategory: classifyToolCallError(error62, errorDetails) };
   }
   return { outcome: summarizeToolCallResult(toolName, result).outcome };
 }
@@ -21264,10 +21389,10 @@ function validateIfConditionLiteral({ condition, context, stepId }) {
       if (!resolved)
         continue;
       anyResolved = true;
-      const error61 = ifConditionLiteralError({ reference, literal: literal2, stepId, schema: resolved });
-      if (!error61)
+      const error62 = ifConditionLiteralError({ reference, literal: literal2, stepId, schema: resolved });
+      if (!error62)
         return null;
-      firstError ??= error61;
+      firstError ??= error62;
     }
     return anyResolved ? firstError : null;
   }
@@ -21328,17 +21453,17 @@ function validateManifestTemplateVariables(data, ctx) {
     };
     if (typeof step.if === "string") {
       for (const variable of extractTemplateVariables(step.if)) {
-        const error61 = validateTemplateVariable({
+        const error62 = validateTemplateVariable({
           variable,
           context,
           stepId: step.id,
           currentStepGuard,
           sourceType: "condition"
         });
-        if (error61) {
+        if (error62) {
           ctx.addIssue({
             code: external_exports.ZodIssueCode.custom,
-            message: error61,
+            message: error62,
             path: ["steps", stepIndex, "if"]
           });
         }
@@ -21359,21 +21484,21 @@ function validateManifestTemplateVariables(data, ctx) {
     if ("prompt" in step && typeof step.prompt === "string") {
       const variables = extractTemplateVariables(step.prompt);
       for (const variable of variables) {
-        const error61 = validateTemplateVariable({
+        const error62 = validateTemplateVariable({
           variable,
           context,
           stepId: step.id,
           currentStepGuard
         });
-        if (!error61)
+        if (!error62)
           continue;
         const parts = variable.split(".");
-        if (parts[0] === "steps" && parts[1] && !context.steps.has(parts[1]) && error61.includes("before it is available")) {
+        if (parts[0] === "steps" && parts[1] && !context.steps.has(parts[1]) && error62.includes("before it is available")) {
           unavailableStepRefs.add(parts[1]);
         } else {
           ctx.addIssue({
             code: external_exports.ZodIssueCode.custom,
-            message: error61,
+            message: error62,
             path: ["steps", stepIndex, "prompt"]
           });
         }
@@ -21392,18 +21517,18 @@ function validateManifestTemplateVariables(data, ctx) {
         if (typeof value !== "string")
           continue;
         for (const variable of extractTemplateVariables(value)) {
-          const error61 = validateTemplateVariable({
+          const error62 = validateTemplateVariable({
             variable,
             context,
             stepId: step.id,
             currentStepGuard,
             sourceType: fieldName
           });
-          if (!error61)
+          if (!error62)
             continue;
           ctx.addIssue({
             code: external_exports.ZodIssueCode.custom,
-            message: error61,
+            message: error62,
             path: ["steps", stepIndex, fieldName]
           });
         }
@@ -22759,6 +22884,7 @@ var UsageBillingEntrySchema = external_exports.object({
 var USAGE_BILLING_ENTRY_TYPES = [
   "usage_settled",
   "top_up",
+  "adjustment",
   "void",
   "expiry",
   "chargeback"
@@ -23369,10 +23495,10 @@ async function request(args) {
   let response;
   try {
     response = await fetch(url2, init);
-  } catch (error61) {
+  } catch (error62) {
     if (signal?.aborted)
-      throw error61;
-    throw new AutomationsNetworkError("Request failed before a response was received", error61);
+      throw error62;
+    throw new AutomationsNetworkError("Request failed before a response was received", error62);
   }
   const data = await readResponseBody(response);
   if (!response.ok) {
@@ -24092,11 +24218,11 @@ var connectionsEndpoints = {
 };
 
 // ../../packages/sdk/dist/esm/clients/connections/connections-client.js
-function getConnectionInUseError(error61) {
-  if (!(error61 instanceof AutomationsRequestError) || error61.httpStatusCode !== 409) {
+function getConnectionInUseError(error62) {
+  if (!(error62 instanceof AutomationsRequestError) || error62.httpStatusCode !== 409) {
     return null;
   }
-  const parsed = ConnectionInUseConflictSchema.safeParse(error61.responseData);
+  const parsed = ConnectionInUseConflictSchema.safeParse(error62.responseData);
   return parsed.success ? parsed.data : null;
 }
 var connectionTokenResponseSchema = external_exports.object({
@@ -24689,6 +24815,145 @@ var AutomationsApi = class {
   }
 };
 
+// ../../packages/sdk/dist/esm/summaries/automation-summary.js
+function summarizeAutomation(automation) {
+  return {
+    ...automation,
+    connections: automation.connections.map((connection) => ({
+      id: connection.id,
+      name: connection.name,
+      connectorId: connection.connectorId,
+      capabilities: connection.capabilities,
+      status: connection.status,
+      createdAt: connection.createdAt
+    }))
+  };
+}
+function summarizeAutomationPage(page) {
+  return { ...page, data: page.data.map(summarizeAutomation) };
+}
+
+// ../../packages/sdk/dist/esm/summaries/run-summary.js
+function summarizeRun(run) {
+  return {
+    id: run.id,
+    automationId: run.automationId,
+    status: run.status,
+    createdAt: run.createdAt,
+    updatedAt: run.updatedAt,
+    failureCategory: getRunOutcomeCategory(run),
+    failureReason: getRunOutcomeReason(run),
+    result: run.result,
+    temporalUrl: run.temporalUrl,
+    steps: run.steps.map((step) => ({
+      stepId: step.stepId,
+      type: step.type,
+      description: step.description,
+      status: step.status,
+      startedAt: step.startedAt,
+      completedAt: step.completedAt,
+      error: step.error,
+      toolCalls: step.toolCalls?.map((toolCall) => ({
+        id: toolCall.id,
+        name: toolCall.name,
+        argumentKeys: toolCall.argumentKeys,
+        hasResult: toolCall.hasResult,
+        hasError: toolCall.hasError,
+        resultPreview: toolCall.resultPreview,
+        errorPreview: toolCall.errorPreview,
+        timestamp: toolCall.timestamp
+      }))
+    }))
+  };
+}
+
+// ../../packages/sdk/dist/esm/connectors/connector-catalog.js
+var ConnectorNotFoundError = class extends Error {
+  connectorId;
+  constructor(connectorId) {
+    super(`Connector ${connectorId} was not found.`);
+    this.name = "ConnectorNotFoundError";
+    this.connectorId = connectorId;
+  }
+};
+async function* iterateConnectorPages(api, query, options) {
+  const seenCursors = /* @__PURE__ */ new Set();
+  let cursor;
+  while (true) {
+    const page = await api.connectors.list({ query, cursor, limit: MAX_PAGINATION_LIMIT }, options);
+    if (page.nextCursor && seenCursors.has(page.nextCursor)) {
+      throw new Error("The API returned a repeated pagination cursor.");
+    }
+    yield page;
+    if (!page.nextCursor)
+      return;
+    seenCursors.add(page.nextCursor);
+    cursor = page.nextCursor;
+  }
+}
+async function findConnector(api, connectorId, options) {
+  for await (const page of iterateConnectorPages(api, void 0, options)) {
+    const connector = page.data.find((item) => item.id === connectorId);
+    if (connector)
+      return connector;
+  }
+  throw new ConnectorNotFoundError(connectorId);
+}
+async function listConnectors(api, options, requestOptions) {
+  const [connectors, connectionResponse] = await Promise.all([
+    collectConnectorPages(api, options.query, requestOptions),
+    options.connections ? api.connections.list({}, requestOptions) : void 0
+  ]);
+  const connectionsByConnector = groupConnectionsByConnector(connectionResponse?.connections ?? []);
+  const data = connectors.filter((connector) => connectorSupportsCapability(connector, options.capability)).map((connector) => options.connections ? enrichConnector(connector, connectionsByConnector.get(connector.id) ?? []) : connector).filter((connector) => matchesConnectionFilters(connector, options));
+  return { connectionsIncluded: options.connections, data };
+}
+function getConnectorCapabilities(connector) {
+  return [
+    ...connector.capabilities.mcp ? ["mcp"] : [],
+    ...connector.capabilities.triggers ? ["trigger"] : []
+  ];
+}
+function connectorSupportsCapability(connector, capability) {
+  return !capability || getConnectorCapabilities(connector).includes(capability);
+}
+function enrichConnector(connector, connections) {
+  return { ...connector, connections: connections.map(summarizeConnectorConnection) };
+}
+function groupConnectionsByConnector(connections) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const connection of connections) {
+    const group = grouped.get(connection.connectorId) ?? [];
+    group.push(connection);
+    grouped.set(connection.connectorId, group);
+  }
+  return grouped;
+}
+function matchesConnectionFilters(connector, options) {
+  if (!connector.connections)
+    return true;
+  if (options.withoutConnections)
+    return connector.connections.length === 0;
+  if (!options.connectionStatus)
+    return true;
+  return connector.connections.some((connection) => connection.status === options.connectionStatus && (!options.capability || connection.capabilities.some((item) => item.capability === options.capability)));
+}
+async function collectConnectorPages(api, query, options) {
+  const connectors = [];
+  for await (const page of iterateConnectorPages(api, query, options)) {
+    connectors.push(...page.data);
+  }
+  return connectors;
+}
+function summarizeConnectorConnection(connection) {
+  return {
+    id: connection.id,
+    status: connection.status,
+    capabilities: connection.capabilities,
+    createdAt: connection.createdAt
+  };
+}
+
 // src/lib/auth-environment.ts
 import { InvalidArgumentError } from "commander";
 var ENVIRONMENTS = {
@@ -25038,9 +25303,9 @@ async function fetchTodoistUser(token, todoistApiUrl) {
     response = await fetch(url2, {
       headers: { Authorization: `Bearer ${token}`, Accept: "application/json" }
     });
-  } catch (error61) {
+  } catch (error62) {
     throw new Error(
-      `Could not reach Todoist to identify the account: ${getErrorMessage(error61)}`
+      `Could not reach Todoist to identify the account: ${getErrorMessage(error62)}`
     );
   }
   if (!response.ok) {
@@ -25051,9 +25316,9 @@ async function fetchTodoistUser(token, todoistApiUrl) {
   let user;
   try {
     user = await response.json();
-  } catch (error61) {
+  } catch (error62) {
     throw new Error(
-      `Todoist returned an unreadable identity response: ${getErrorMessage(error61)}`
+      `Todoist returned an unreadable identity response: ${getErrorMessage(error62)}`
     );
   }
   return { id: requireUserId(user.id), email: typeof user.email === "string" ? user.email : "" };
@@ -25066,16 +25331,16 @@ function requireUserId(id) {
 
 // src/lib/errors.ts
 import { getErrorMessage as getErrorMessage2 } from "@doist/cli-core";
-function getErrorCode(error61) {
-  return typeof error61 === "object" && error61 !== null && "code" in error61 ? String(error61.code) : void 0;
+function getErrorCode(error62) {
+  return typeof error62 === "object" && error62 !== null && "code" in error62 ? String(error62.code) : void 0;
 }
-function formatError2(error61) {
-  const hints = errorHints(error61);
-  return [getErrorMessage2(error61), ...hints.map((hint) => `  - ${hint}`)].join("\n");
+function formatError2(error62) {
+  const hints = errorHints(error62);
+  return [getErrorMessage2(error62), ...hints.map((hint) => `  - ${hint}`)].join("\n");
 }
-function errorHints(error61) {
-  if (typeof error61 !== "object" || error61 === null || !("hints" in error61)) return [];
-  const hints = error61.hints;
+function errorHints(error62) {
+  if (typeof error62 !== "object" || error62 === null || !("hints" in error62)) return [];
+  const hints = error62.hints;
   return Array.isArray(hints) ? hints.filter((hint) => typeof hint === "string") : [];
 }
 
@@ -25106,8 +25371,8 @@ async function resolveCredential(options = {}) {
   let snapshot;
   try {
     snapshot = await store2.activeBundle();
-  } catch (error61) {
-    return resolveAfterStoreFailure(error61);
+  } catch (error62) {
+    return resolveAfterStoreFailure(error62);
   }
   if (!snapshot) return fromEnvironment() ?? raiseNotAuthenticated();
   const accessToken = await freshAccessToken(store2, snapshot, options.minimumTokenLifetimeMs);
@@ -25129,12 +25394,12 @@ async function freshAccessToken(store2, snapshot, minimumTokenLifetimeMs) {
       handshake: { env: getEnvironment().name }
     });
     return result.bundle.accessToken;
-  } catch (error61) {
-    return accessTokenAfterFailedRefresh(error61, snapshot);
+  } catch (error62) {
+    return accessTokenAfterFailedRefresh(error62, snapshot);
   }
 }
-function accessTokenAfterFailedRefresh(error61, snapshot) {
-  switch (getErrorCode(error61)) {
+function accessTokenAfterFailedRefresh(error62, snapshot) {
+  switch (getErrorCode(error62)) {
     case "AUTH_REFRESH_UNAVAILABLE":
       return snapshot.bundle.accessToken;
     case "AUTH_REFRESH_EXPIRED":
@@ -25145,7 +25410,7 @@ function accessTokenAfterFailedRefresh(error61, snapshot) {
       if (hasTokenLifeLeft(snapshot)) return snapshot.bundle.accessToken;
       throw new CredentialError(
         "REFRESH_FAILED",
-        `Could not refresh your access token: ${getErrorMessage3(error61)}`,
+        `Could not refresh your access token: ${getErrorMessage3(error62)}`,
         ["Check your network connection and try again."]
       );
   }
@@ -25161,8 +25426,8 @@ function fromEnvironment() {
 function raiseNotAuthenticated() {
   throw new NotAuthenticatedError();
 }
-function resolveAfterStoreFailure(error61) {
-  const code = getErrorCode(error61);
+function resolveAfterStoreFailure(error62) {
+  const code = getErrorCode(error62);
   if (code === "NO_ACCOUNT_SELECTED") {
     throw new CredentialError(
       "ACCOUNT_AMBIGUOUS",
@@ -25173,25 +25438,25 @@ function resolveAfterStoreFailure(error61) {
   if (code !== "AUTH_STORE_READ_FAILED") {
     throw new CredentialError(
       "CREDENTIAL_UNREADABLE",
-      `Could not read the stored credential: ${getErrorMessage3(error61)}`,
+      `Could not read the stored credential: ${getErrorMessage3(error62)}`,
       ["Run `tda auth logout` and then `tda auth login` to replace it."]
     );
   }
   const fallback = fromEnvironment();
   if (fallback) {
     process.stderr.write(
-      `Warning: could not read the stored credential (${getErrorMessage3(error61)}). Using ${TOKEN_ENV_VAR}.
+      `Warning: could not read the stored credential (${getErrorMessage3(error62)}). Using ${TOKEN_ENV_VAR}.
 `
     );
     return fallback;
   }
-  throw new CredentialError("CREDENTIAL_UNREADABLE", getErrorMessage3(error61), [
+  throw new CredentialError("CREDENTIAL_UNREADABLE", getErrorMessage3(error62), [
     `Set ${TOKEN_ENV_VAR} to bypass the credential store.`,
     "Or re-run `tda auth login --credential-store plaintext`."
   ]);
 }
-function explainAuthFailure(error61, source) {
-  const status = httpStatus(error61);
+function explainAuthFailure(error62, source) {
+  const status = httpStatus(error62);
   if (status === 401) {
     return source === "env" ? new CredentialError("NOT_AUTHENTICATED", `Your ${TOKEN_ENV_VAR} was rejected.`, [
       "Check the token is a valid Todoist API token.",
@@ -25200,14 +25465,14 @@ function explainAuthFailure(error61, source) {
       "Run `tda auth login` to sign in again."
     ]);
   }
-  if (status === 403 && isInsufficientScopeChallenge(authChallenge(error61))) {
+  if (status === 403 && isInsufficientScopeChallenge(authChallenge(error62))) {
     return new CredentialError(
       "INSUFFICIENT_SCOPE",
       "Your login does not grant what this command needs.",
-      insufficientScopeFixes(requiredScope(error61))
+      insufficientScopeFixes(requiredScope(error62))
     );
   }
-  return error61;
+  return error62;
 }
 function insufficientScopeFixes(scope) {
   if (!scope) {
@@ -25222,23 +25487,23 @@ function insufficientScopeFixes(scope) {
     flag ? `Run \`tda auth login --additional-scopes ${flag}\` to grant it.` : "Run `tda auth login` to authorize again, without --read-only."
   ];
 }
-function requiredScope(error61) {
-  return readStringProperty(error61, "requiredScope");
+function requiredScope(error62) {
+  return readStringProperty(error62, "requiredScope");
 }
-function authChallenge(error61) {
-  return readStringProperty(error61, "authChallenge");
+function authChallenge(error62) {
+  return readStringProperty(error62, "authChallenge");
 }
-function httpStatus(error61) {
-  const status = readProperty(error61, "httpStatusCode");
+function httpStatus(error62) {
+  const status = readProperty(error62, "httpStatusCode");
   return typeof status === "number" ? status : void 0;
 }
-function readStringProperty(error61, key) {
-  const value = readProperty(error61, key);
+function readStringProperty(error62, key) {
+  const value = readProperty(error62, key);
   return typeof value === "string" ? value : void 0;
 }
-function readProperty(error61, key) {
-  if (typeof error61 !== "object" || error61 === null || !(key in error61)) return void 0;
-  return error61[key];
+function readProperty(error62, key) {
+  if (typeof error62 !== "object" || error62 === null || !(key in error62)) return void 0;
+  return error62[key];
 }
 
 // src/lib/api-configuration.ts
@@ -25891,8 +26156,8 @@ async function revokeToken(token) {
       signal: AbortSignal.timeout(REVOKE_TIMEOUT_MS)
     });
     return response.ok ? void 0 : `HTTP ${response.status}`;
-  } catch (error61) {
-    return getErrorMessage4(error61);
+  } catch (error62) {
+    return getErrorMessage4(error62);
   }
 }
 
@@ -26057,8 +26322,8 @@ async function writeNdjsonItem(item, stream = process.stdout) {
 }
 
 // src/lib/command-error.ts
-function renderFailure(error61, context = {}) {
-  const explained = context.source ? explainAuthFailure(error61, context.source) : error61;
+function renderFailure(error62, context = {}) {
+  const explained = context.source ? explainAuthFailure(error62, context.source) : error62;
   const code = getErrorCode(explained);
   return {
     message: getErrorMessage5(explained),
@@ -26108,7 +26373,7 @@ async function runApiCommand(command, operation, presentation, execution = {}) {
     );
     stopEarlySpinner();
     writeResult(mode, result, presentation);
-  } catch (error61) {
+  } catch (error62) {
     if (abortController.signal.aborted) {
       writeFailure(mode, "interrupted", {
         message: "Interrupted.",
@@ -26117,7 +26382,7 @@ async function runApiCommand(command, operation, presentation, execution = {}) {
       process.exitCode = 130;
       return;
     }
-    writeFailure(mode, "error", renderFailure(error61, { mode, source }));
+    writeFailure(mode, "error", renderFailure(error62, { mode, source }));
     process.exitCode = 1;
   } finally {
     process.removeListener("SIGINT", onInterrupt);
@@ -26176,22 +26441,6 @@ function formatAutomation(automation) {
     formatValue(automation.manifest)
   ].join("\n");
 }
-function summarizeAutomation(automation) {
-  return {
-    ...automation,
-    connections: automation.connections.map((connection) => ({
-      id: connection.id,
-      name: connection.name,
-      connectorId: connection.connectorId,
-      capabilities: connection.capabilities,
-      status: connection.status,
-      createdAt: connection.createdAt
-    }))
-  };
-}
-function summarizeAutomationPage(page) {
-  return { ...page, data: page.data.map(summarizeAutomation) };
-}
 function formatDraftList(page) {
   if (page.data.length === 0) return "No drafts found.";
   return withNextCursor(
@@ -26293,38 +26542,6 @@ function formatRun(run) {
   }
   return lines.join("\n");
 }
-function summarizeRun(run) {
-  return {
-    id: run.id,
-    automationId: run.automationId,
-    status: run.status,
-    createdAt: run.createdAt,
-    updatedAt: run.updatedAt,
-    failureCategory: getRunOutcomeCategory(run),
-    failureReason: getRunOutcomeReason(run),
-    result: run.result,
-    temporalUrl: run.temporalUrl,
-    steps: run.steps.map((step) => ({
-      stepId: step.stepId,
-      type: step.type,
-      description: step.description,
-      status: step.status,
-      startedAt: step.startedAt,
-      completedAt: step.completedAt,
-      error: step.error,
-      toolCalls: step.toolCalls?.map((toolCall) => ({
-        id: toolCall.id,
-        name: toolCall.name,
-        argumentKeys: toolCall.argumentKeys,
-        hasResult: toolCall.hasResult,
-        hasError: toolCall.hasError,
-        resultPreview: toolCall.resultPreview,
-        errorPreview: toolCall.errorPreview,
-        timestamp: toolCall.timestamp
-      }))
-    }))
-  };
-}
 function getResourceName(manifest) {
   if (!isRecord2(manifest)) return "(unnamed)";
   return typeof manifest.name === "string" && manifest.name.trim() ? manifest.name : "(unnamed)";
@@ -26558,13 +26775,13 @@ async function runStreamingCommand(command, handlers) {
     const context = { options, mode, output: output2, signal: abortController.signal };
     const result = await handlers.operation(context);
     await handlers.onSuccess(result, context);
-  } catch (error61) {
+  } catch (error62) {
     const state = { mode, output: output2, signal: abortController.signal };
     if (abortController.signal.aborted) {
       await handlers.onInterrupted(state);
       process.exitCode = 130;
     } else {
-      await handlers.onError(error61, state);
+      await handlers.onError(error62, state);
       process.exitCode = 1;
     }
   } finally {
@@ -26573,10 +26790,79 @@ async function runStreamingCommand(command, handlers) {
   }
 }
 
-// src/commands/chat/chat-service.ts
-import { getErrorMessage as getErrorMessage6 } from "@doist/cli-core";
-import { createInterface } from "node:readline/promises";
-import pLimit from "p-limit";
+// ../../packages/sdk/dist/esm/chat-turn/connection-requirements.js
+var CONNECTION_LOOKUP_CONCURRENCY = 4;
+function deduplicateConnectionRequirements(requirements) {
+  const seen = /* @__PURE__ */ new Set();
+  return requirements.filter((requirement) => {
+    const key = JSON.stringify([requirement.connectorId, requirement.connectionType]);
+    if (seen.has(key))
+      return false;
+    seen.add(key);
+    return true;
+  });
+}
+async function loadConnectionRequirements(connections, requirements, options) {
+  return mapWithConcurrency(deduplicateConnectionRequirements(requirements), CONNECTION_LOOKUP_CONCURRENCY, async (requirement) => {
+    const response = await connections.list({
+      connectorId: requirement.connectorId,
+      capability: requirement.connectionType,
+      status: "authorized"
+    }, options);
+    return {
+      ...requirement,
+      availableConnections: response.connections.map((connection) => ({
+        id: connection.id,
+        label: connection.accountDisplayLabel ?? connection.name ?? connection.id
+      }))
+    };
+  });
+}
+async function mapWithConcurrency(items, concurrency, map2) {
+  const results = new Array(items.length);
+  let next = 0;
+  const workers = Array.from({ length: Math.min(concurrency, items.length) }, async () => {
+    while (next < items.length) {
+      const index = next;
+      next += 1;
+      results[index] = await map2(items[index]);
+    }
+  });
+  await Promise.all(workers);
+  return results;
+}
+
+// ../../packages/sdk/dist/esm/chat-turn/connection-setup.js
+async function startConnectionSetup(connections, request2, options) {
+  const created = await connections.create({
+    connectorId: request2.connectorId,
+    capability: request2.capability,
+    ...request2.automationIds?.length ? { body: { automationIds: [...request2.automationIds] } } : {}
+  }, options);
+  return { connectionId: created.connectionId, setup: created.setup, resumed: false };
+}
+function summarizeConnectionSetup(setup) {
+  if (setup?.kind === "oauth") {
+    return { setupKind: "oauth", authorizationUrl: setup.authorizationUrl };
+  }
+  if (setup?.kind === "managed") {
+    return {
+      setupKind: "managed",
+      instructions: setup.instructions,
+      code: setup.code,
+      deepLinkUrl: setup.deepLinkUrl,
+      expiresAt: setup.expiresAt
+    };
+  }
+  return { setupKind: "none" };
+}
+function getConnectionSetupUrl(setup) {
+  if (setup?.kind === "oauth")
+    return setup.authorizationUrl;
+  if (setup?.kind === "managed")
+    return setup.deepLinkUrl;
+  return null;
+}
 
 // ../../packages/core/dist/esm/chat-tools/client-tool-result.js
 var clientToolContinuationPartSchema = external_exports.discriminatedUnion("type", [
@@ -26611,11 +26897,10 @@ var toolUpdateMemoryResultSchema = external_exports.object({
   output: UpdateMemoryOutputSchema
 });
 
-// src/commands/chat/chat-message.ts
-import { randomUUID } from "node:crypto";
+// ../../packages/sdk/dist/esm/chat-turn/messages.js
 function createUserMessage(text) {
   return {
-    id: randomUUID(),
+    id: globalThis.crypto.randomUUID(),
     role: "user",
     parts: [{ type: "text", text }]
   };
@@ -26634,9 +26919,7 @@ function toUiMessage(message) {
   };
 }
 function getVisibleText(message) {
-  return message.parts.filter(
-    (part) => part.type === "text"
-  ).map((part) => part.text).join("");
+  return message.parts.filter((part) => part.type === "text").map((part) => part.text).join("");
 }
 function getPendingClientAction(message) {
   for (let index = message.parts.length - 1; index >= 0; index -= 1) {
@@ -26661,6 +26944,12 @@ function getPendingClientAction(message) {
   }
   return null;
 }
+function getPendingActionFromMessages(messages) {
+  const latestMessage = messages.at(-1);
+  if (!latestMessage || latestMessage.role !== "assistant")
+    return null;
+  return getPendingClientAction(toUiMessage(latestMessage));
+}
 function getPublishedAutomationId(message) {
   for (let index = message.parts.length - 1; index >= 0; index -= 1) {
     const part = message.parts[index];
@@ -26685,7 +26974,181 @@ function createSelectConnectionsContinuation(action, output2) {
   };
 }
 
-// src/commands/chat/chat-transport.ts
+// ../../packages/sdk/dist/esm/chat-turn/types.js
+var ChatTurnInputError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "ChatTurnInputError";
+    this.code = code;
+  }
+};
+
+// ../../packages/sdk/dist/esm/chat-turn/run-conversation-turn.js
+async function runConversationTurn(options) {
+  const { api, transport, conversationId, signal } = options;
+  const workspaceId = options.workspaceId ?? null;
+  const requestOptions = { signal };
+  const pending = await readPendingAction(options);
+  let nextMessage;
+  if (pending?.kind === "enable_push") {
+    if ("selections" in options.input && options.input.selections.length > 0) {
+      throw new ChatTurnInputError("not_awaiting_selection", "The conversation is not waiting for connection selection.");
+    }
+    return actionRequired(conversationId, getVisibleText(pending.message), {
+      kind: "enable_push",
+      toolCallId: pending.toolCallId,
+      draftId: pending.draftId
+    });
+  }
+  if ("message" in options.input) {
+    if (pending?.kind === "select_connections") {
+      throw new ChatTurnInputError("awaiting_selection", "The conversation is waiting for connection selection.");
+    }
+    nextMessage = createUserMessage(options.input.message);
+  } else {
+    const selections = options.input.selections;
+    if (pending?.kind !== "select_connections") {
+      throw new ChatTurnInputError(selections.length > 0 ? "not_awaiting_selection" : "input_required", selections.length > 0 ? "The conversation is not waiting for connection selection." : "A message is required to continue.");
+    }
+    const resolution = await resolveSelectConnections(options, pending, selections);
+    if (resolution.kind === "required") {
+      return actionRequired(conversationId, getVisibleText(pending.message), resolution.pendingAction);
+    }
+    nextMessage = resolution.continuation;
+  }
+  while (true) {
+    const response = await transport.streamTurn({
+      conversationId,
+      workspaceId,
+      message: nextMessage,
+      signal,
+      onText: options.onText,
+      onToolActivity: options.onToolActivity
+    });
+    const assistantText = getVisibleText(response);
+    const automationId = getPublishedAutomationId(response);
+    if (automationId) {
+      options.onPublished?.(automationId);
+      const archive = await archiveConversation(api, conversationId, requestOptions);
+      return {
+        conversationId,
+        outcome: "published",
+        assistantText,
+        automationId,
+        ...archive
+      };
+    }
+    const responseAction = getPendingClientAction(response);
+    if (responseAction?.kind === "select_connections") {
+      const resolution = await resolveSelectConnections(options, responseAction, []);
+      if (resolution.kind === "resolved") {
+        nextMessage = resolution.continuation;
+        continue;
+      }
+      return actionRequired(conversationId, assistantText, resolution.pendingAction);
+    }
+    if (responseAction?.kind === "enable_push") {
+      return actionRequired(conversationId, assistantText, {
+        kind: "enable_push",
+        toolCallId: responseAction.toolCallId,
+        draftId: responseAction.draftId
+      });
+    }
+    return { conversationId, outcome: "awaiting_input", assistantText };
+  }
+}
+async function readPendingAction(options) {
+  if (options.pendingAction !== void 0)
+    return options.pendingAction;
+  const messages = await options.api.chat.getMessages(options.conversationId, {
+    signal: options.signal
+  });
+  return getPendingActionFromMessages(messages);
+}
+function actionRequired(conversationId, assistantText, pendingAction) {
+  return { conversationId, outcome: "action_required", assistantText, pendingAction };
+}
+async function archiveConversation(api, conversationId, requestOptions) {
+  try {
+    const conversation = await api.chat.updateConversation(conversationId, { isArchived: true }, requestOptions);
+    if (!conversation.isArchived) {
+      throw new Error("The Automations API returned an active conversation.");
+    }
+    return { conversationArchived: true };
+  } catch (error62) {
+    return {
+      conversationArchived: false,
+      conversationArchiveError: error62 instanceof Error ? error62.message : String(error62)
+    };
+  }
+}
+async function resolveSelectConnections(options, action, selections) {
+  const { api, signal } = options;
+  const requestOptions = { signal };
+  const requirements = await loadConnectionRequirements(api.connections, action.connections, requestOptions);
+  assertSelectionsUnambiguous(requirements, selections);
+  const resolved = [];
+  for (const requirement of requirements) {
+    const explicit = selections.find((selection) => selection.connectorId === requirement.connectorId && (!selection.connectionType || selection.connectionType === requirement.connectionType));
+    let connectionId = explicit?.connectionId;
+    let setup;
+    if (connectionId) {
+      const exists = requirement.availableConnections.some((connection) => connection.id === connectionId);
+      if (!exists) {
+        throw new ChatTurnInputError("unknown_connection", `Connection ${connectionId} is not an authorized ${requirement.serviceName} connection.`);
+      }
+    } else if (requirement.availableConnections.length === 1) {
+      connectionId = requirement.availableConnections[0]?.id;
+    } else if (requirement.availableConnections.length > 1) {
+      connectionId = await options.chooseConnection?.(requirement);
+    } else if (options.authorizeConnection) {
+      connectionId = await options.authorizeConnection(requirement);
+    } else {
+      setup = await startConnectionSetup(api.connections, { connectorId: requirement.connectorId, capability: requirement.connectionType }, requestOptions);
+    }
+    if (!connectionId) {
+      return {
+        kind: "required",
+        pendingAction: {
+          kind: "select_connections",
+          toolCallId: action.toolCallId,
+          draftId: action.draftId,
+          requirements: requirements.map((item) => item === requirement && setup ? { ...item, setup } : item)
+        }
+      };
+    }
+    resolved.push({ requirement, connectionId });
+  }
+  const output2 = [];
+  for (const item of resolved) {
+    const body = {
+      connectorId: item.requirement.connectorId,
+      connectionType: item.requirement.connectionType,
+      connectionId: item.connectionId
+    };
+    const workspaceId = options.workspaceId ?? null;
+    if (workspaceId === null) {
+      await api.automationDraftConnections.upsert(action.draftId, body, requestOptions);
+    } else {
+      await api.workspaceAutomationDraftConnections.upsert(workspaceId, action.draftId, body, requestOptions);
+    }
+    output2.push({ type: "success", ...body });
+  }
+  return { kind: "resolved", continuation: createSelectConnectionsContinuation(action, output2) };
+}
+function assertSelectionsUnambiguous(requirements, selections) {
+  for (const selection of selections) {
+    if (selection.connectionType)
+      continue;
+    const matchingTypes = new Set(requirements.filter((requirement) => requirement.connectorId === selection.connectorId).map((requirement) => requirement.connectionType));
+    if (matchingTypes.size > 1) {
+      throw new ChatTurnInputError("ambiguous_selection", `Connection selection for ${selection.connectorId} is ambiguous. Specify ${selection.connectorId}:mcp or ${selection.connectorId}:trigger.`);
+    }
+  }
+}
+
+// ../../packages/sdk/dist/esm/chat-turn/transport.js
 import { DefaultChatTransport, readUIMessageStream } from "ai";
 var ChatTurnTransport = class {
   transport;
@@ -26712,14 +27175,7 @@ var ChatTurnTransport = class {
     });
   }
   /** Streams one server turn, reporting incremental text and deduplicated tool state changes. */
-  async streamTurn({
-    conversationId,
-    workspaceId = null,
-    message,
-    signal,
-    onText,
-    onToolActivity
-  }) {
+  async streamTurn({ conversationId, workspaceId = null, message, signal, onText, onToolActivity }) {
     const stream = await this.transport.sendMessages({
       trigger: "submit-message",
       chatId: conversationId,
@@ -26739,14 +27195,17 @@ var ChatTurnTransport = class {
       const visibleText = getVisibleText(currentMessage);
       if (visibleText.startsWith(emittedText)) {
         const delta = visibleText.slice(emittedText.length);
-        if (delta) onText(delta);
+        if (delta)
+          onText?.(delta);
         emittedText = visibleText;
       }
       for (const part of currentMessage.parts) {
         const activity = toToolActivity(part);
-        if (!activity) continue;
+        if (!activity)
+          continue;
         const key = `${activity.toolCallId}:${activity.state}`;
-        if (emittedToolStates.has(key)) continue;
+        if (emittedToolStates.has(key))
+          continue;
         emittedToolStates.add(key);
         onToolActivity?.(activity);
       }
@@ -26768,6 +27227,9 @@ function toToolActivity(part) {
   };
 }
 
+// src/commands/chat/chat-service.ts
+import { createInterface } from "node:readline/promises";
+
 // src/commands/chat/connection-authorizer.ts
 import open2 from "open";
 import { setTimeout as wait } from "node:timers/promises";
@@ -27084,11 +27546,12 @@ var ApiConnectionAuthorizer = class {
     this.timeoutMs = timeoutMs ?? CONNECTION_AUTHORIZATION_TIMEOUT_MS;
   }
   async authorize(request2, signal) {
-    const created = await this.connections.create(
+    const created = await startConnectionSetup(
+      this.connections,
       {
         connectorId: request2.connectorId,
         capability: request2.connectionType,
-        ...request2.automationIds?.length ? { body: { automationIds: [...request2.automationIds] } } : {}
+        automationIds: request2.automationIds
       },
       { signal }
     );
@@ -27115,19 +27578,12 @@ var ApiConnectionAuthorizer = class {
       connectionType: request2.connectionType,
       state: "waiting_for_user",
       terminal: false,
-      setupKind: setup?.kind ?? "none",
-      ...resumed ? { resumed: true } : {},
-      ...setup?.kind === "oauth" ? { authorizationUrl: setup.authorizationUrl } : {},
-      ...setup?.kind === "managed" ? {
-        instructions: setup.instructions,
-        code: setup.code,
-        deepLinkUrl: setup.deepLinkUrl,
-        expiresAt: setup.expiresAt
-      } : {}
+      ...summarizeConnectionSetup(setup),
+      ...resumed ? { resumed: true } : {}
     });
   }
   async openSetup(request2, connectionId, setup, signal) {
-    const url2 = setup?.kind === "oauth" ? setup.authorizationUrl : setup?.kind === "managed" ? setup.deepLinkUrl : null;
+    const url2 = getConnectionSetupUrl(setup);
     if (!url2 || !this.openBrowser || !isSafeSetupUrl(url2)) return;
     try {
       signal?.throwIfAborted();
@@ -27142,8 +27598,8 @@ var ApiConnectionAuthorizer = class {
         state: "waiting_for_user",
         terminal: false
       });
-    } catch (error61) {
-      if (signal?.aborted) throw error61;
+    } catch (error62) {
+      if (signal?.aborted) throw error62;
       this.output.emit({
         type: "warning",
         code: "TDA_BROWSER_OPEN_FAILED",
@@ -27208,22 +27664,11 @@ function isSafeSetupUrl(value) {
   }
 }
 
-// src/commands/chat/connection-requirements.ts
-function deduplicateConnectionRequirements(requirements) {
-  const seen = /* @__PURE__ */ new Set();
-  return requirements.filter((requirement) => {
-    const key = JSON.stringify([requirement.connectorId, requirement.connectionType]);
-    if (seen.has(key)) return false;
-    seen.add(key);
-    return true;
-  });
-}
-
 // src/commands/chat/conversation-turn-lock.ts
 import { link, mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID } from "node:crypto";
 var ConversationTurnLock = class {
   directory;
   pid;
@@ -27237,7 +27682,7 @@ var ConversationTurnLock = class {
   async acquire(conversationId) {
     await mkdir(this.directory, { recursive: true, mode: 448 });
     const path = join(this.directory, `${encodeURIComponent(conversationId)}.lock`);
-    const ownerId = randomUUID2();
+    const ownerId = randomUUID();
     const pendingPath = `${path}.${ownerId}.pending`;
     await writeFile(
       pendingPath,
@@ -27255,8 +27700,8 @@ var ConversationTurnLock = class {
             const current2 = await readLock(path);
             if (current2?.ownerId === ownerId) await rm(path, { force: true });
           };
-        } catch (error61) {
-          if (!isFileExistsError(error61)) throw error61;
+        } catch (error62) {
+          if (!isFileExistsError(error62)) throw error62;
         }
         const current = await readLock(path);
         if (current && this.isProcessRunning(current.pid)) {
@@ -27277,8 +27722,8 @@ async function readLock(path) {
     if (typeof value === "object" && value !== null && typeof value.ownerId === "string" && typeof value.pid === "number") {
       return value;
     }
-  } catch (error61) {
-    if (!isFileMissingError(error61) && !(error61 instanceof SyntaxError)) throw error61;
+  } catch (error62) {
+    if (!isFileMissingError(error62) && !(error62 instanceof SyntaxError)) throw error62;
   }
   return null;
 }
@@ -27291,23 +27736,22 @@ function isProcessRunning(pid) {
   try {
     process.kill(pid, 0);
     return true;
-  } catch (error61) {
-    return !isNoSuchProcessError(error61);
+  } catch (error62) {
+    return !isNoSuchProcessError(error62);
   }
 }
-function isFileExistsError(error61) {
-  return getErrorCode(error61) === "EEXIST";
+function isFileExistsError(error62) {
+  return getErrorCode(error62) === "EEXIST";
 }
-function isFileMissingError(error61) {
-  return getErrorCode(error61) === "ENOENT";
+function isFileMissingError(error62) {
+  return getErrorCode(error62) === "ENOENT";
 }
-function isNoSuchProcessError(error61) {
-  return getErrorCode(error61) === "ESRCH";
+function isNoSuchProcessError(error62) {
+  return getErrorCode(error62) === "ESRCH";
 }
 
 // src/commands/chat/chat-service.ts
 var TURN_HEARTBEAT_INTERVAL_MS = 15e3;
-var CONNECTION_LOOKUP_CONCURRENCY = 4;
 var TURN_RUNNING_MESSAGE = "Keep monitoring this process; do not invoke continue until turn_completed with terminal=true is emitted and the process exits.";
 var ChatService = class {
   api;
@@ -27351,12 +27795,12 @@ var ChatService = class {
     this.output.emit({ type: "session_started", conversationId: conversation.id });
     return this.withActiveTurn(
       conversation.id,
-      () => this.runConversationUntilTerminal({
-        conversationId: conversation.id,
-        workspaceId: conversation.workspaceId,
-        incomingMessage: createUserMessage(message),
-        signal
-      })
+      () => this.runUntilTerminal(
+        { conversationId: conversation.id, workspaceId: conversation.workspaceId },
+        { message },
+        signal,
+        null
+      )
     );
   }
   /** Resumes a persisted conversation with a message or pending connection selections. */
@@ -27367,59 +27811,26 @@ var ChatService = class {
     signal
   }) {
     const conversation = await this.api.chat.getConversation(conversationId, { signal });
-    const { workspaceId } = conversation;
+    const scope = { conversationId, workspaceId: conversation.workspaceId };
     return this.withActiveTurn(
       conversationId,
       async () => {
-        let incomingMessage;
         const pendingAction = await this.getPersistedPendingAction(conversationId, signal);
-        if (pendingAction?.kind === "select_connections") {
-          if (message) {
-            throw new Error(
-              "Use either a message or --connection selections, not both."
-            );
-          }
-          const resolution = await this.resolveSelectConnections(
-            { conversationId, workspaceId },
-            pendingAction,
-            selections,
-            this.interactive,
-            signal
-          );
-          if (resolution.kind === "required") {
-            return this.completeRequiredConnectionAction(
-              conversationId,
-              getVisibleText(pendingAction.message),
-              resolution.action
-            );
-          }
-          incomingMessage = resolution.continuation;
-        } else if (pendingAction?.kind === "enable_push") {
-          if (selections.length > 0) {
-            throw new Error("The conversation is not waiting for connection selection.");
-          }
-          return this.completeRequiredPushAction(
-            conversationId,
-            getVisibleText(pendingAction.message),
-            pendingAction
-          );
-        } else if (selections.length > 0) {
-          throw new Error("The conversation is not waiting for connection selection.");
+        let input2;
+        if (message) {
+          input2 = { message };
+        } else if (selections.length > 0 || pendingAction) {
+          input2 = { selections };
         } else {
-          const nextMessage = message ?? (this.interactive ? await this.promptForMessage(signal) : "");
+          const nextMessage = this.interactive ? await this.promptForMessage(signal) : "";
           if (!nextMessage) {
             throw new Error(
               "A message or --connection selection is required to continue."
             );
           }
-          incomingMessage = createUserMessage(nextMessage);
+          input2 = { message: nextMessage };
         }
-        return this.runConversationUntilTerminal({
-          conversationId,
-          workspaceId,
-          incomingMessage,
-          signal
-        });
+        return this.runUntilTerminal(scope, input2, signal, pendingAction);
       },
       () => this.output.emit({ type: "session_resumed", conversationId })
     );
@@ -27451,13 +27862,12 @@ var ChatService = class {
   close() {
     this.readline?.close();
   }
-  async runConversationUntilTerminal({
-    conversationId,
-    workspaceId,
-    incomingMessage,
-    signal
-  }) {
-    let nextIncomingMessage = incomingMessage;
+  /**
+   * Runs server turns until one ends somewhere the CLI has to stop: a pending client action,
+   * a publication, or, outside an interactive terminal, the agent waiting for input.
+   */
+  async runUntilTerminal(scope, input2, signal, pendingAction) {
+    const { conversationId } = scope;
     const startedAt = Date.now();
     let lastActivityAt = startedAt;
     const markActivity = () => {
@@ -27477,67 +27887,29 @@ var ChatService = class {
     }, this.heartbeatIntervalMs);
     heartbeat?.unref();
     try {
+      let nextInput = input2;
+      let knownPendingAction = pendingAction;
       while (true) {
-        const response = await this.transport.streamTurn({
-          conversationId,
-          workspaceId,
-          message: nextIncomingMessage,
-          signal,
-          onText: (text) => {
-            markActivity();
-            this.output.emit({ type: "assistant_text", conversationId, text });
-          },
-          onToolActivity: (activity) => {
-            markActivity();
-            this.output.emit({ type: "tool_activity", conversationId, ...activity });
-          }
+        const result = await this.runTurn(scope, nextInput, signal, knownPendingAction, {
+          markActivity
         });
-        const assistantText = getVisibleText(response);
-        const automationId = getPublishedAutomationId(response);
-        if (automationId) {
-          this.output.emit({ type: "published", conversationId, automationId });
-          const conversationArchived = await this.archivePublishedConversation(
-            conversationId,
-            signal
-          );
+        if (result.outcome === "published") {
+          this.emitArchiveResult(result);
           return this.completeTurn({
             conversationId,
-            assistantText,
+            assistantText: result.assistantText,
             status: "published",
-            automationId,
-            conversationArchived
+            automationId: result.automationId,
+            conversationArchived: result.conversationArchived
           });
         }
-        const pendingAction = getPendingClientAction(response);
-        if (pendingAction?.kind === "select_connections") {
-          const resolution = await this.resolveSelectConnections(
-            { conversationId, workspaceId },
-            pendingAction,
-            [],
-            this.interactive,
-            signal
-          );
-          if (resolution.kind === "resolved") {
-            nextIncomingMessage = resolution.continuation;
-            continue;
-          }
-          return this.completeRequiredConnectionAction(
-            conversationId,
-            assistantText,
-            resolution.action
-          );
-        }
-        if (pendingAction?.kind === "enable_push") {
-          return this.completeRequiredPushAction(
-            conversationId,
-            assistantText,
-            pendingAction
-          );
+        if (result.outcome === "action_required" && result.pendingAction) {
+          return this.completeRequiredAction(result, result.pendingAction);
         }
         if (!this.interactive) {
           return this.completeTurn({
             conversationId,
-            assistantText,
+            assistantText: result.assistantText,
             status: "awaiting_input"
           });
         }
@@ -27545,17 +27917,76 @@ var ChatService = class {
         if (!userMessage || userMessage === "/exit") {
           return this.completeTurn({
             conversationId,
-            assistantText,
+            assistantText: result.assistantText,
             status: "awaiting_input"
           });
         }
         markActivity();
-        nextIncomingMessage = createUserMessage(userMessage);
+        nextInput = { message: userMessage };
+        knownPendingAction = null;
       }
     } finally {
       if (heartbeat) clearInterval(heartbeat);
     }
   }
+  async runTurn({ conversationId, workspaceId }, input2, signal, pendingAction, { markActivity }) {
+    try {
+      return await runConversationTurn({
+        api: this.api,
+        transport: this.transport,
+        conversationId,
+        workspaceId,
+        input: input2,
+        pendingAction,
+        signal,
+        onText: (text) => {
+          markActivity();
+          this.output.emit({ type: "assistant_text", conversationId, text });
+        },
+        onToolActivity: (activity) => {
+          markActivity();
+          this.output.emit({ type: "tool_activity", conversationId, ...activity });
+        },
+        onPublished: (automationId) => {
+          this.output.emit({ type: "published", conversationId, automationId });
+        },
+        chooseConnection: this.interactive ? (requirement) => this.promptForConnection(requirement, signal) : void 0,
+        authorizeConnection: async (requirement) => {
+          if (this.interactive && !await this.confirmConnectionAuthorization(requirement, signal)) {
+            return void 0;
+          }
+          return this.connectionAuthorizer.authorize(
+            { ...requirement, conversationId },
+            signal
+          );
+        }
+      });
+    } catch (error62) {
+      if (error62 instanceof ChatTurnInputError) {
+        throw new Error(describeInputError(error62));
+      }
+      throw error62;
+    }
+  }
+  emitArchiveResult(result) {
+    if (result.conversationArchived) {
+      this.output.emit({
+        type: "conversation_archived",
+        conversationId: result.conversationId,
+        state: "completed",
+        terminal: false
+      });
+      return;
+    }
+    this.output.emit({
+      type: "warning",
+      code: "TDA_CHAT_ARCHIVE_FAILED",
+      conversationId: result.conversationId,
+      message: `The automation was published, but its chat could not be archived: ${result.conversationArchiveError}`,
+      state: "warning",
+      terminal: false
+    });
+  }
   completeTurn(summary) {
     const resumeCommand = getResumeCommand(summary);
     this.output.emit({
@@ -27570,66 +28001,23 @@ var ChatService = class {
     });
     return summary;
   }
-  completeRequiredConnectionAction(conversationId, assistantText, action) {
+  completeRequiredAction(result, pendingAction) {
+    const { conversationId } = result;
+    const action = toRequiredActionPayload(pendingAction);
     this.output.emit({
       type: "action_required",
       conversationId,
-      action: "select_connections",
-      message: "Select or authorize the required service connections.",
+      action: pendingAction.kind,
+      message: pendingAction.kind === "select_connections" ? "Select or authorize the required service connections." : "Enable Todoist push notifications in a supported Todoist client.",
       ...action
     });
     return this.completeTurn({
       conversationId,
-      assistantText,
+      assistantText: result.assistantText,
       status: "action_required",
       action
     });
   }
-  completeRequiredPushAction(conversationId, assistantText, action) {
-    const actionPayload = toActionPayload(action);
-    this.output.emit({
-      type: "action_required",
-      conversationId,
-      action: action.kind,
-      message: "Enable Todoist push notifications in a supported Todoist client.",
-      ...actionPayload
-    });
-    return this.completeTurn({
-      conversationId,
-      assistantText,
-      status: "action_required",
-      action: actionPayload
-    });
-  }
-  async archivePublishedConversation(conversationId, signal) {
-    try {
-      const conversation = await this.api.chat.updateConversation(
-        conversationId,
-        { isArchived: true },
-        { signal }
-      );
-      if (!conversation.isArchived) {
-        throw new Error("The Automations API returned an active conversation.");
-      }
-      this.output.emit({
-        type: "conversation_archived",
-        conversationId,
-        state: "completed",
-        terminal: false
-      });
-      return true;
-    } catch (error61) {
-      this.output.emit({
-        type: "warning",
-        code: "TDA_CHAT_ARCHIVE_FAILED",
-        conversationId,
-        message: `The automation was published, but its chat could not be archived: ${getErrorMessage6(error61)}`,
-        state: "warning",
-        terminal: false
-      });
-      return false;
-    }
-  }
   async withActiveTurn(conversationId, operation, onAcquired) {
     const release = await this.turnLock.acquire(conversationId);
     onAcquired?.();
@@ -27650,108 +28038,6 @@ var ChatService = class {
     const messages = await this.api.chat.getMessages(conversationId, { signal });
     return getPendingActionFromMessages(messages);
   }
-  async resolveSelectConnections({ conversationId, workspaceId }, action, selections, allowPrompt, signal) {
-    const uniqueConnections = deduplicateConnectionRequirements(action.connections);
-    const limitConnectionLookup = pLimit(CONNECTION_LOOKUP_CONCURRENCY);
-    const requirements = await Promise.all(
-      uniqueConnections.map(
-        (connection) => limitConnectionLookup(async () => {
-          const response = await this.api.connections.list(
-            {
-              connectorId: connection.connectorId,
-              capability: connection.connectionType,
-              status: "authorized"
-            },
-            { signal }
-          );
-          return {
-            ...connection,
-            availableConnections: response.connections.map((availableConnection) => ({
-              id: availableConnection.id,
-              label: availableConnection.accountDisplayLabel ?? availableConnection.name ?? availableConnection.id
-            }))
-          };
-        })
-      )
-    );
-    for (const selection of selections) {
-      if (selection.connectionType) continue;
-      const matchingTypes = new Set(
-        requirements.filter((requirement) => requirement.connectorId === selection.connectorId).map((requirement) => requirement.connectionType)
-      );
-      if (matchingTypes.size > 1) {
-        throw new Error(
-          `Connection selection for ${selection.connectorId} is ambiguous. Specify ${selection.connectorId}:mcp or ${selection.connectorId}:trigger.`
-        );
-      }
-    }
-    const resolved = [];
-    for (const requirement of requirements) {
-      const explicit = selections.find(
-        (selection) => selection.connectorId === requirement.connectorId && (!selection.connectionType || selection.connectionType === requirement.connectionType)
-      );
-      let connectionId = explicit?.connectionId;
-      if (connectionId) {
-        const exists = requirement.availableConnections.some(
-          (connection) => connection.id === connectionId
-        );
-        if (!exists) {
-          throw new Error(
-            `Connection ${connectionId} is not an authorized ${requirement.serviceName} connection.`
-          );
-        }
-      } else if (requirement.availableConnections.length === 1) {
-        connectionId = requirement.availableConnections[0]?.id;
-      } else if (allowPrompt && requirement.availableConnections.length > 1) {
-        connectionId = await this.promptForConnection(requirement, signal);
-      } else if (requirement.availableConnections.length === 0 && (!this.interactive || await this.confirmConnectionAuthorization(requirement, signal))) {
-        connectionId = await this.connectionAuthorizer.authorize(
-          { ...requirement, conversationId },
-          signal
-        );
-      }
-      if (!connectionId) {
-        return {
-          kind: "required",
-          action: {
-            toolCallId: action.toolCallId,
-            draftId: action.draftId,
-            requirements,
-            resume: requirements.some((item) => item.availableConnections.length === 0) ? "tda chat continue <conversation-id>" : "tda chat continue <conversation-id> --connection <connector-id>=<connection-id>"
-          }
-        };
-      }
-      resolved.push({ requirement, connectionId });
-    }
-    const output2 = [];
-    for (const item of resolved) {
-      const body = {
-        connectorId: item.requirement.connectorId,
-        connectionType: item.requirement.connectionType,
-        connectionId: item.connectionId
-      };
-      if (workspaceId === null) {
-        await this.api.automationDraftConnections.upsert(action.draftId, body, { signal });
-      } else {
-        await this.api.workspaceAutomationDraftConnections.upsert(
-          workspaceId,
-          action.draftId,
-          body,
-          { signal }
-        );
-      }
-      output2.push({
-        type: "success",
-        connectionId: item.connectionId,
-        connectorId: item.requirement.connectorId,
-        connectionType: item.requirement.connectionType
-      });
-    }
-    return {
-      kind: "resolved",
-      continuation: createSelectConnectionsContinuation(action, output2)
-    };
-  }
   async promptForConnection(requirement, signal) {
     const readline = this.getReadline();
     process.stdout.write(
@@ -27786,10 +28072,28 @@ No authorized ${sanitizeTerminalText(requirement.serviceName)} connection exists
     return this.readline;
   }
 };
-function getPendingActionFromMessages(messages) {
-  const latestMessage = messages.at(-1);
-  if (!latestMessage || latestMessage.role !== "assistant") return null;
-  return getPendingClientAction(toUiMessage(latestMessage));
+function describeInputError(error62) {
+  switch (error62.code) {
+    case "awaiting_selection":
+      return "Use either a message or --connection selections, not both.";
+    case "not_awaiting_selection":
+      return "The conversation is not waiting for connection selection.";
+    case "input_required":
+      return "A message or --connection selection is required to continue.";
+    default:
+      return error62.message;
+  }
+}
+function toRequiredActionPayload(action) {
+  if (action.kind === "enable_push") {
+    return { toolCallId: action.toolCallId, draftId: action.draftId };
+  }
+  return {
+    toolCallId: action.toolCallId,
+    draftId: action.draftId,
+    requirements: action.requirements,
+    resume: action.requirements.some((item) => item.availableConnections.length === 0) ? "tda chat continue <conversation-id>" : "tda chat continue <conversation-id> --connection <connector-id>=<connection-id>"
+  };
 }
 function toActionPayload(action) {
   if (action.kind === "select_connections") {
@@ -27917,8 +28221,8 @@ async function runCommand(command, operation) {
         assistantText: ""
       });
     },
-    onError: (error61, { mode, output: output2 }) => {
-      const failure2 = renderFailure(error61, { mode, source });
+    onError: (error62, { mode, output: output2 }) => {
+      const failure2 = renderFailure(error62, { mode, source });
       const message = mode === "human" ? failure2.humanMessage : failure2.message;
       output2.emit({
         type: "error",
@@ -28049,31 +28353,19 @@ function formatConnectionChange(result) {
       return `Connection ${result.connectionId} authorized.`;
   }
 }
-function getConnectorCapabilities(connector) {
-  return [
-    ...connector.capabilities.mcp ? ["mcp"] : [],
-    ...connector.capabilities.triggers ? ["trigger"] : []
-  ];
-}
 
 // src/commands/connector/connector-service.ts
-async function listConnectors(api, options, signal) {
+async function listConnectors2(api, options, signal) {
   validateListOptions(options);
-  const [connectors, connectionResponse] = await Promise.all([
-    listAllConnectors(api, options.query, signal),
-    options.connections ? api.connections.list({}, { signal }) : void 0
-  ]);
-  const connectionsByConnector = groupConnections(connectionResponse?.connections ?? []);
-  const data = connectors.filter((connector) => connectorSupportsCapability(connector, options.capability)).map(
-    (connector) => options.connections ? enrichConnector(connector, connectionsByConnector.get(connector.id) ?? []) : connector
-  ).filter((connector) => matchesConnectionFilters(connector, options));
-  return { connectionsIncluded: options.connections, data };
+  return listConnectors(api, options, { signal });
 }
 async function* streamConnectorNdjsonItems(api, options, signal) {
   validateListOptions(options);
   const connectionResponse = options.connections ? await api.connections.list({}, { signal }) : void 0;
-  const connectionsByConnector = groupConnections(connectionResponse?.connections ?? []);
-  for await (const page of iterateConnectorPages(api, options.query, signal)) {
+  const connectionsByConnector = groupConnectionsByConnector(
+    connectionResponse?.connections ?? []
+  );
+  for await (const page of iterateConnectorPages(api, options.query, { signal })) {
     for (const connector of page.data) {
       if (!connectorSupportsCapability(connector, options.capability)) continue;
       const enriched = options.connections ? enrichConnector(connector, connectionsByConnector.get(connector.id) ?? []) : connector;
@@ -28082,49 +28374,8 @@ async function* streamConnectorNdjsonItems(api, options, signal) {
   }
   yield { _meta: true, connectionsIncluded: options.connections };
 }
-async function findConnector(api, connectorId, signal) {
-  for await (const page of iterateConnectorPages(api, void 0, signal)) {
-    const connector = page.data.find((item) => item.id === connectorId);
-    if (connector) return connector;
-  }
-  throw new Error(`Connector ${connectorId} was not found.`);
-}
-function enrichConnector(connector, connections) {
-  return { ...connector, connections: connections.map(summarizeConnection) };
-}
-function connectorSupportsCapability(connector, capability) {
-  if (!capability) return true;
-  return capability === "mcp" ? connector.capabilities.mcp !== void 0 : connector.capabilities.triggers !== void 0;
-}
-async function listAllConnectors(api, query, signal) {
-  const { data } = await collectCursorPages(
-    { all: true },
-    (args) => api.connectors.list({ query, ...args }, { signal })
-  );
-  return data;
-}
-function iterateConnectorPages(api, query, signal) {
-  return iterateCursorPages(
-    { all: true },
-    (args) => api.connectors.list({ query, ...args }, { signal })
-  );
-}
-function groupConnections(connections) {
-  const grouped = /* @__PURE__ */ new Map();
-  for (const connection of connections) {
-    const group = grouped.get(connection.connectorId) ?? [];
-    group.push(connection);
-    grouped.set(connection.connectorId, group);
-  }
-  return grouped;
-}
-function summarizeConnection(connection) {
-  return {
-    id: connection.id,
-    status: connection.status,
-    capabilities: connection.capabilities,
-    createdAt: connection.createdAt
-  };
+function findConnector2(api, connectorId, signal) {
+  return findConnector(api, connectorId, { signal });
 }
 function validateListOptions(options) {
   if (!options.connections && (options.connectionStatus || options.withoutConnections)) {
@@ -28134,14 +28385,6 @@ function validateListOptions(options) {
     throw new Error("--connection-status cannot be combined with --without-connections.");
   }
 }
-function matchesConnectionFilters(connector, options) {
-  if (!connector.connections) return true;
-  if (options.withoutConnections) return connector.connections.length === 0;
-  if (!options.connectionStatus) return true;
-  return connector.connections.some(
-    (connection) => connection.status === options.connectionStatus && (!options.capability || connection.capabilities.some((item) => item.capability === options.capability))
-  );
-}
 
 // src/commands/connector/authorization-command.ts
 async function runAuthorizationCommand(command, operation) {
@@ -28179,8 +28422,8 @@ async function runAuthorizationCommand(command, operation) {
       });
       output2.finish({ status: "interrupted", message: "Interrupted." });
     },
-    onError: (error61, { mode, output: output2 }) => {
-      const failure2 = renderFailure(error61, { mode, source });
+    onError: (error62, { mode, output: output2 }) => {
+      const failure2 = renderFailure(error62, { mode, source });
       const message = mode === "human" ? failure2.humanMessage : failure2.message;
       output2.emit({
         type: "error",
@@ -28223,10 +28466,10 @@ async function disconnectConnection(api, connectionId, { confirmed, force }, sig
   }
   try {
     await api.connections.delete(connectionId, { signal, force });
-  } catch (error61) {
-    const conflict = getConnectionInUseError(error61);
+  } catch (error62) {
+    const conflict = getConnectionInUseError(error62);
     if (!conflict) {
-      throw error61;
+      throw error62;
     }
     const details = conflict.automations.map((automation) => `${automation.id} (${automation.name})`).join(", ");
     throw new Error(
@@ -28263,7 +28506,7 @@ function registerConnectorMutationCommands(connector) {
     new Option3("--capability <capability>", "Capability to authorize").choices(["mcp", "trigger"]).makeOptionMandatory()
   ).action(async (connectorId, options, command) => {
     await runAuthorizationCommand(command, async ({ api, authorizer, signal }) => {
-      const selected2 = await findConnector(api, connectorId, signal);
+      const selected2 = await findConnector2(api, connectorId, signal);
       assertConnectorSupportsCapability(selected2, options.capability);
       if (!selected2.requiresConnection) {
         throw new Error(`${selected2.name} does not require a connection.`);
@@ -28363,7 +28606,7 @@ function registerConnectorReadCommands(connector) {
   ).option("--without-connections", "Only include connectors with no connection records").option("--no-connections", "Do not fetch or include user connections").action(async (options, command) => {
     await runApiCommand(
       command,
-      ({ api, signal }) => listConnectors(api, options, signal),
+      ({ api, signal }) => listConnectors2(api, options, signal),
       {
         human: formatConnectorList
       },
@@ -28378,7 +28621,7 @@ function registerConnectorReadCommands(connector) {
       command,
       async ({ api, signal }) => {
         const [selected2, connections] = await Promise.all([
-          findConnector(api, connectorId, signal),
+          findConnector2(api, connectorId, signal),
           api.connections.list({ connectorId }, { signal })
         ]);
         return enrichConnector(selected2, connections.connections);
@@ -28551,8 +28794,8 @@ async function runLocalCommand(command, operation, presentation, execution = {})
     const result = await withSpinner({ text: execution.spinner ?? "Loading..." }, operation);
     stopEarlySpinner();
     writeResult(mode, result, presentation);
-  } catch (error61) {
-    writeFailure(mode, "error", renderFailure(error61, { mode }));
+  } catch (error62) {
+    writeFailure(mode, "error", renderFailure(error62, { mode }));
     process.exitCode = 1;
   }
 }
@@ -28669,7 +28912,7 @@ async function updateAllSkills(options, command) {
         throw new CliError3(
           "UPDATE_FAILED",
           `Could not update ${result.errors.length} skill file(s).`,
-          { hints: result.errors.map((error61) => `${error61.agent}: ${error61.message}`) }
+          { hints: result.errors.map((error62) => `${error62.agent}: ${error62.message}`) }
         );
       }
       return { action: "updated_all", ...result };
@@ -28866,9 +29109,9 @@ if (isEntrypoint()) {
   try {
     startEarlySpinner();
     await createProgram().parseAsync(process.argv);
-  } catch (error61) {
+  } catch (error62) {
     stopEarlySpinner();
-    process.stderr.write(`error: ${formatError2(error61)}
+    process.stderr.write(`error: ${formatError2(error62)}
 `);
     process.exitCode = 1;
   } finally {