@doist/automations-cli 1.20.3 → 1.21.1

package/dist/index.js

@@ -7,7 +7,7 @@ import {
   collectSkillStatus,
   getInstaller,
   updateAllInstalledSkills
-} from "./chunk-GUWS3EHG.js";
+} from "./chunk-ZWFZ2DD3.js";
 
 // ../../node_modules/ajv/dist/compile/codegen/code.js
 var require_code = __commonJS({
@@ -6899,7 +6899,7 @@ import { fileURLToPath } from "node:url";
 // package.json
 var package_default = {
   name: "@doist/automations-cli",
-  version: "1.20.3",
+  version: "1.21.1",
   description: "Command-line client for Todoist Automations",
   type: "module",
   bin: {
@@ -6944,7 +6944,7 @@ var package_default = {
   },
   dependencies: {
     "@doist/cli-core": "1.7.0",
-    "@napi-rs/keyring": "2.1.0",
+    "@napi-rs/keyring": "2.1.1",
     ai: "7.0.137",
     commander: "15.0.0",
     oauth4webapi: "3.8.8",
@@ -28149,6 +28149,7 @@ var cronScheduleSchema = (() => {
   });
 })();
 var scheduleValueSchema = external_exports.union([intervalScheduleSchema, cronScheduleSchema]).meta({ description: "The schedule definition for the trigger." });
+var TRIGGER_TYPES = ["schedule", "webhook", "api"];
 var scheduleTriggerSchema = external_exports.object({
   type: external_exports.literal("schedule"),
   value: scheduleValueSchema,
@@ -29326,8 +29327,29 @@ var automationDraftListResponseSchema = external_exports.object({
 var finalizeAutomationDraftResponseSchema = external_exports.object({
   automation: automationSchema
 });
+var draftTestTriggerSelectorSchema = external_exports.union([
+  external_exports.object({ index: external_exports.int().min(0) }),
+  external_exports.object({ event: external_exports.string().min(1) })
+]);
+var testAutomationDraftRequestSchema = external_exports.object({
+  trigger: draftTestTriggerSelectorSchema.optional(),
+  payload: external_exports.unknown().optional(),
+  metadata: external_exports.record(external_exports.string(), external_exports.unknown()).optional()
+}).meta({ id: "TestAutomationDraftRequest" });
+var draftTestTriggerSchema = external_exports.object({
+  index: external_exports.int().min(0),
+  count: external_exports.int().min(1),
+  type: external_exports.enum(TRIGGER_TYPES),
+  event: external_exports.string().optional(),
+  inputSource: external_exports.enum(["schedule", "sample-event", "supplied", "empty"])
+});
 var testAutomationDraftResponseSchema = external_exports.object({
-  success: external_exports.literal(true)
+  success: external_exports.literal(true),
+  draftId: external_exports.string(),
+  testRunId: external_exports.string(),
+  status: external_exports.enum(AUTOMATION_RUN_STATUSES),
+  connectorCalls: external_exports.literal("mocked"),
+  trigger: draftTestTriggerSchema
 });
 var AUTOMATION_OPEN_DRAFT_CONFLICT_CODE = "automation_open_draft_conflict";
 var AutomationOpenDraftConflictSchema = external_exports.object({
@@ -29340,6 +29362,18 @@ var AutomationDraftNotReadySchema = external_exports.object({
   code: external_exports.literal(AUTOMATION_DRAFT_NOT_READY_CODE),
   message: external_exports.string()
 });
+var DRAFT_TEST_REQUEST_ERROR_CODES = [
+  "draft_test_not_ready",
+  "draft_test_trigger_not_found",
+  "draft_test_payload_required",
+  "draft_test_payload_filtered",
+  "draft_test_payload_invalid",
+  "draft_test_payload_unsupported"
+];
+var DraftTestRequestErrorSchema = external_exports.object({
+  code: external_exports.enum(DRAFT_TEST_REQUEST_ERROR_CODES),
+  message: external_exports.string()
+});
 
 // ../../packages/core/dist/esm/schemas/automation-draft-connection.schema.js
 var CreateAutomationDraftConnectionSchema = external_exports.object({
@@ -29651,10 +29685,23 @@ var automationTestRunStepStatusSchema = external_exports.object({
   stepId: external_exports.string().min(1),
   status: external_exports.enum(AUTOMATION_RUN_STATUSES)
 });
+var automationTestRunFailedStepSchema = external_exports.object({
+  stepId: external_exports.string().min(1),
+  description: external_exports.string().optional(),
+  error: external_exports.string().optional()
+});
 var automationTestRunProgressSchema = external_exports.object({
   draftId: external_exports.string().min(1),
   status: external_exports.enum(AUTOMATION_RUN_STATUSES),
-  steps: external_exports.array(automationTestRunStepStatusSchema).default([])
+  steps: external_exports.array(automationTestRunStepStatusSchema).default([]),
+  // Optional so results stored before these fields existed still parse.
+  runId: external_exports.string().min(1).optional(),
+  failedStep: automationTestRunFailedStepSchema.optional(),
+  /** Why a failed or skipped run stopped. */
+  error: external_exports.string().optional(),
+  result: AutomationRunResultSchema.nullable().optional(),
+  /** A test run simulates every connector call, reads included. */
+  connectorCalls: external_exports.literal("mocked").optional()
 });
 var automationTestRunPreviewTriggerSchema = external_exports.union([
   external_exports.object({
@@ -29947,6 +29994,47 @@ var cohortMatrixResponseSchema = external_exports.object({
   rows: external_exports.array(cohortMatrixRowSchema)
 });
 
+// ../../packages/core/dist/esm/schemas/draft-test-run.schema.js
+var DraftTestRunFailedStepSchema = external_exports.object({
+  stepId: external_exports.string(),
+  description: external_exports.string(),
+  error: external_exports.string().nullable()
+});
+var draftTestRunDetailDtoBaseShape = {
+  id: external_exports.string(),
+  draftId: external_exports.string(),
+  // The automation an edit draft belongs to; null for a draft of a new automation.
+  automationId: external_exports.string().nullable(),
+  mode: external_exports.literal("test"),
+  // A test run simulates every connector call, reads included, with a model.
+  connectorCalls: external_exports.literal("mocked"),
+  createdAt: external_exports.string(),
+  updatedAt: external_exports.string(),
+  result: AutomationRunResultSchema.nullable(),
+  temporalUrl: external_exports.string().nullish(),
+  steps: external_exports.array(AutomationRunStepDtoSchema),
+  failedStep: DraftTestRunFailedStepSchema.nullable()
+};
+var DraftTestRunDetailDtoSchema = external_exports.discriminatedUnion("status", [
+  external_exports.object({ ...draftTestRunDetailDtoBaseShape, status: external_exports.literal("pending") }),
+  external_exports.object({ ...draftTestRunDetailDtoBaseShape, status: external_exports.literal("running") }),
+  external_exports.object({ ...draftTestRunDetailDtoBaseShape, status: external_exports.literal("completed") }),
+  external_exports.object({ ...draftTestRunDetailDtoBaseShape, status: external_exports.literal("cancelled") }),
+  external_exports.object({ ...draftTestRunDetailDtoBaseShape, status: external_exports.literal("data-expired") }),
+  external_exports.object({
+    ...draftTestRunDetailDtoBaseShape,
+    status: external_exports.literal("failed"),
+    failureReason: external_exports.string().nullish(),
+    failureCategory: external_exports.enum(FAILURE_CATEGORIES).nullish().catch(null)
+  }),
+  external_exports.object({
+    ...draftTestRunDetailDtoBaseShape,
+    status: external_exports.literal("skipped"),
+    skipReason: external_exports.string().nullish(),
+    skipCategory: external_exports.enum(SKIP_CATEGORIES).nullish()
+  })
+]);
+
 // ../../packages/core/dist/esm/types/workspace.types.js
 var WORKSPACE_PLANS = ["STARTER", "BUSINESS"];
 var WORKSPACE_ROLES = ["ADMIN", "MEMBER", "GUEST"];
@@ -31117,7 +31205,8 @@ var automationDraftsEndpoints = {
   list: root3,
   detail: (id) => `${root3}/${encodeURIComponent(id)}`,
   finalize: (id) => `${root3}/${encodeURIComponent(id)}/finalize`,
-  test: (id) => `${root3}/${encodeURIComponent(id)}/test`
+  test: (id) => `${root3}/${encodeURIComponent(id)}/test`,
+  testRun: (id, runId) => `${root3}/${encodeURIComponent(id)}/test-runs/${encodeURIComponent(runId)}`
 };
 
 // ../../packages/sdk/dist/esm/clients/automation-drafts/automation-drafts-client.js
@@ -31131,6 +31220,16 @@ function getDraftNotReadyError(error62) {
   const parsed = AutomationDraftNotReadySchema.safeParse(error62.responseData);
   return parsed.success ? parsed.data : null;
 }
+function getDraftTestRequestError(error62) {
+  if (!(error62 instanceof AutomationsRequestError) || error62.httpStatusCode !== 400) {
+    return null;
+  }
+  const parsed = DraftTestRequestErrorSchema.safeParse(error62.responseData);
+  return parsed.success ? parsed.data : null;
+}
+function isRequestOptions(value) {
+  return Boolean(value && ("signal" in value || "headers" in value));
+}
 var AutomationDraftsClient = class extends BaseClient {
   async list(args = {}, options) {
     const { cursor, limit } = CursorPaginationSchema.parse(args);
@@ -31191,16 +31290,35 @@ var AutomationDraftsClient = class extends BaseClient {
     });
     return finalizeAutomationDraftResponseSchema.parse(data);
   }
-  async test(draftId, options) {
+  /** Starts a test run; `request` picks the trigger and supplies the event to test with. */
+  async test(draftId, requestOrOptions, options) {
     const id = IdSchema.parse(draftId);
+    const request2 = isRequestOptions(requestOrOptions) ? void 0 : requestOrOptions;
     const data = await this.request({
       method: "POST",
       path: automationDraftsEndpoints.test(id),
-      options
+      body: request2 ? testAutomationDraftRequestSchema.parse(request2) : void 0,
+      options: isRequestOptions(requestOrOptions) ? requestOrOptions : options
     });
     return testAutomationDraftResponseSchema.parse(data);
   }
+  /** A test run of this draft, with its steps; `args` match the run detail's. */
+  async getTestRun(draftId, runId, args = {}, options) {
+    const data = await this.request({
+      method: "GET",
+      path: automationDraftsEndpoints.testRun(IdSchema.parse(draftId), IdSchema.parse(runId)),
+      query: toTestRunQuery(args),
+      options
+    });
+    return DraftTestRunDetailDtoSchema.parse(data);
+  }
 };
+function toTestRunQuery(args) {
+  return {
+    includeGeneratedCode: args.includeGeneratedCode ? true : void 0,
+    includeToolCallPreviews: args.includeToolCallPreviews
+  };
+}
 
 // ../../packages/sdk/dist/esm/clients/automation-runs/endpoints.js
 var automationRunsEndpoints = {
@@ -31209,7 +31327,7 @@ var automationRunsEndpoints = {
 };
 
 // ../../packages/sdk/dist/esm/clients/automation-runs/automation-runs-client.js
-function isRequestOptions(value) {
+function isRequestOptions2(value) {
   return Boolean(value && ("signal" in value || "headers" in value));
 }
 var AutomationRunsClient = class extends BaseClient {
@@ -31228,8 +31346,8 @@ var AutomationRunsClient = class extends BaseClient {
   async get(automationId, runId, argsOrOptions, options) {
     const aId = IdSchema.parse(automationId);
     const rId = IdSchema.parse(runId);
-    const args = isRequestOptions(argsOrOptions) ? void 0 : argsOrOptions;
-    const requestOptions = isRequestOptions(argsOrOptions) ? argsOrOptions : options;
+    const args = isRequestOptions2(argsOrOptions) ? void 0 : argsOrOptions;
+    const requestOptions = isRequestOptions2(argsOrOptions) ? argsOrOptions : options;
     const data = await this.request({
       method: "GET",
       path: automationRunsEndpoints.detail(aId, rId),
@@ -31488,7 +31606,9 @@ var WorkspaceAutomationDraftConnectionsClient = class extends BaseClient {
 var workspaceAutomationDraftsEndpoints = {
   list: (workspaceId) => `${root7(workspaceId)}`,
   detail: (workspaceId, id) => `${root7(workspaceId)}/${encodeURIComponent(id)}`,
-  finalize: (workspaceId, id) => `${root7(workspaceId)}/${encodeURIComponent(id)}/finalize`
+  finalize: (workspaceId, id) => `${root7(workspaceId)}/${encodeURIComponent(id)}/finalize`,
+  test: (workspaceId, id) => `${root7(workspaceId)}/${encodeURIComponent(id)}/test`,
+  testRun: (workspaceId, id, runId) => `${root7(workspaceId)}/${encodeURIComponent(id)}/test-runs/${encodeURIComponent(runId)}`
 };
 function root7(workspaceId) {
   return `/workspaces/${encodeURIComponent(workspaceId)}/automation-drafts`;
@@ -31554,6 +31674,24 @@ var WorkspaceAutomationDraftsClient = class extends BaseClient {
     });
     return finalizeAutomationDraftResponseSchema.parse(data);
   }
+  async test(workspaceId, draftId, request2 = {}, options) {
+    const data = await this.request({
+      method: "POST",
+      path: workspaceAutomationDraftsEndpoints.test(IdSchema.parse(workspaceId), IdSchema.parse(draftId)),
+      body: testAutomationDraftRequestSchema.parse(request2),
+      options
+    });
+    return testAutomationDraftResponseSchema.parse(data);
+  }
+  async getTestRun(workspaceId, draftId, runId, args = {}, options) {
+    const data = await this.request({
+      method: "GET",
+      path: workspaceAutomationDraftsEndpoints.testRun(IdSchema.parse(workspaceId), IdSchema.parse(draftId), IdSchema.parse(runId)),
+      query: toTestRunQuery(args),
+      options
+    });
+    return DraftTestRunDetailDtoSchema.parse(data);
+  }
 };
 
 // ../../packages/sdk/dist/esm/clients/workspace-chat/endpoints.js
@@ -32497,25 +32635,47 @@ function summarizeRun(run) {
     result: run.result,
     temporalUrl: run.temporalUrl,
     triggeredBy: run.triggeredBy,
-    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
-      }))
+    steps: summarizeRunSteps(run.steps)
+  };
+}
+function summarizeRunSteps(steps) {
+  return 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/summaries/draft-test-run-summary.js
+function summarizeDraftTestRun(run) {
+  return {
+    id: run.id,
+    draftId: run.draftId,
+    automationId: run.automationId,
+    status: run.status,
+    connectorCalls: run.connectorCalls,
+    createdAt: run.createdAt,
+    updatedAt: run.updatedAt,
+    failureCategory: getRunOutcomeCategory(run),
+    failureReason: getRunOutcomeReason(run),
+    failedStep: run.failedStep,
+    result: run.result,
+    temporalUrl: run.temporalUrl,
+    steps: summarizeRunSteps(run.steps)
   };
 }
 
@@ -32712,6 +32872,313 @@ async function findAutomationsUsingConnection(api, connectionId, options) {
   }
 }
 
+// ../../packages/sdk/dist/esm/drafts/draft-api.js
+function bindDraftApi(api, workspaceId, { signal } = {}) {
+  const createOptions = { signal, translate: false };
+  const listConnections = (args) => api.connections.list(args, { signal });
+  if (workspaceId === null) {
+    return {
+      workspaceId: null,
+      get: (draftId) => api.automationDrafts.get(draftId, { signal }),
+      create: (manifest) => api.automationDrafts.create(manifest, createOptions),
+      update: (draftId, manifest) => api.automationDrafts.update(draftId, manifest, { signal }),
+      createAutomationDraft: (automationId) => api.automations.createDraft(automationId, { signal }),
+      upsertConnection: (draftId, body) => api.automationDraftConnections.upsert(draftId, body, { signal }),
+      getConnectionStatus: async (draftId) => (await api.automationDraftConnections.getStatus(draftId, { signal })).validation,
+      listConnections,
+      finalize: (draftId) => api.automationDrafts.finalize(draftId, { signal }),
+      getAutomation: (automationId) => api.automations.get(automationId, { signal }),
+      test: (draftId, request2) => api.automationDrafts.test(draftId, request2, { signal }),
+      getTestRun: (draftId, runId, args, requestSignal) => api.automationDrafts.getTestRun(draftId, runId, args, {
+        signal: requestSignal ?? signal
+      })
+    };
+  }
+  return {
+    workspaceId,
+    get: (draftId) => api.workspaceAutomationDrafts.get(workspaceId, draftId, { signal }),
+    create: (manifest) => api.workspaceAutomationDrafts.create(workspaceId, manifest, createOptions),
+    update: (draftId, manifest) => api.workspaceAutomationDrafts.update(workspaceId, draftId, manifest, { signal }),
+    createAutomationDraft: (automationId) => api.workspaceAutomations.createDraft(workspaceId, automationId, { signal }),
+    upsertConnection: (draftId, body) => api.workspaceAutomationDraftConnections.upsert(workspaceId, draftId, body, { signal }),
+    getConnectionStatus: async (draftId) => (await api.workspaceAutomationDraftConnections.getStatus(workspaceId, draftId, {
+      signal
+    })).validation,
+    listConnections,
+    finalize: (draftId) => api.workspaceAutomationDrafts.finalize(workspaceId, draftId, { signal }),
+    getAutomation: (automationId) => api.workspaceAutomations.get(workspaceId, automationId, { signal }),
+    test: (draftId, request2) => api.workspaceAutomationDrafts.test(workspaceId, draftId, request2, { signal }),
+    getTestRun: (draftId, runId, args, requestSignal) => api.workspaceAutomationDrafts.getTestRun(workspaceId, draftId, runId, args, {
+      signal: requestSignal ?? signal
+    })
+  };
+}
+
+// ../../packages/sdk/dist/esm/drafts/draft-workflow-error.js
+var DraftWorkflowError = class extends Error {
+  code;
+  draftId;
+  automationId;
+  constructor(code, message, options = {}) {
+    super(message, { cause: options.cause });
+    this.name = "DraftWorkflowError";
+    this.code = code;
+    this.draftId = options.draftId;
+    this.automationId = options.automationId;
+  }
+};
+function getErrorMessage(error62) {
+  return error62 instanceof Error ? error62.message : String(error62);
+}
+
+// ../../packages/sdk/dist/esm/drafts/draft-changes.js
+async function createDraft(draftApi, { manifest, automationId }) {
+  const partialManifest = parsePartialManifest(manifest);
+  if (automationId === void 0) {
+    const result = await draftApi.create(partialManifest);
+    return { action: "created", target: toDraftTarget(result.draft), ...result };
+  }
+  const { draft } = await openEditDraft(draftApi, automationId);
+  try {
+    const result = await draftApi.update(draft.id, partialManifest);
+    return { action: "created", target: toDraftTarget(result.draft), ...result };
+  } catch (error62) {
+    if (!isManifestRejection(error62))
+      throw error62;
+    throw new DraftWorkflowError("draft_manifest_rejected", `Opened draft ${draft.id} for automation ${automationId}, but the manifest was rejected: ${getErrorMessage(error62)}`, { draftId: draft.id, automationId, cause: error62 });
+  }
+}
+async function updateDraft(draftApi, { draftId, manifest }) {
+  const partialManifest = parsePartialManifest(manifest);
+  const result = await draftApi.update(draftId, partialManifest);
+  return { action: "updated", target: toDraftTarget(result.draft), ...result };
+}
+function toDraftTarget(draft) {
+  return draft.automationId === null ? { kind: "new" } : { kind: "automation", automationId: draft.automationId };
+}
+function parsePartialManifest(value) {
+  const validation = validatePartialManifest(value);
+  if (!validation.isValid) {
+    throw new DraftWorkflowError("manifest_invalid", `Manifest is invalid: ${validation.errors.join("; ")}`);
+  }
+  return validation.data;
+}
+async function openEditDraft(draftApi, automationId) {
+  try {
+    return await draftApi.createAutomationDraft(automationId);
+  } catch (error62) {
+    const conflict = getOpenDraftConflictError(error62);
+    if (!conflict)
+      throw error62;
+    throw new DraftWorkflowError("draft_conflict", `Automation ${automationId} already has an open draft ${conflict.draftId}.`, { draftId: conflict.draftId, automationId, cause: error62 });
+  }
+}
+function isManifestRejection(error62) {
+  return error62 instanceof AutomationsRequestError && (error62.httpStatusCode === 400 || error62.httpStatusCode === 422);
+}
+
+// ../../packages/sdk/dist/esm/drafts/connect-draft.js
+async function connectDraft(draftApi, { draftId, selections, auto }) {
+  const bound = [];
+  const required2 = selections.length > 0 ? getRequiredConnectorsFromManifest((await draftApi.get(draftId)).draft.partialManifest) : /* @__PURE__ */ new Map();
+  const explicit = selections.flatMap((selection) => {
+    const types = required2.get(selection.connectorId);
+    if (!types || selection.connectionType && !types.has(selection.connectionType)) {
+      const slot = selection.connectionType ? `${selection.connectorId} (${selection.connectionType})` : selection.connectorId;
+      throw new DraftWorkflowError("connector_not_required", `Connector ${slot} is not used by draft ${draftId}. Required: ${describeRequired(required2)}.`, { draftId });
+    }
+    const connectionTypes = selection.connectionType ? [selection.connectionType] : [...types];
+    return connectionTypes.map((connectionType) => ({ ...selection, connectionType }));
+  });
+  for (const { connectorId, connectionType, connectionId } of explicit) {
+    await draftApi.upsertConnection(draftId, { connectorId, connectionType, connectionId });
+    bound.push({ connectorId, connectionType, connectionId, mode: "explicit" });
+  }
+  const unresolved = [];
+  if (auto) {
+    const status = await draftApi.getConnectionStatus(draftId);
+    for (const connector of status.connectors) {
+      for (const connectionType of ["mcp", "trigger"]) {
+        const slot = connector[connectionType];
+        if (!slot.required || slot.status !== "missing")
+          continue;
+        const { connections } = await draftApi.listConnections({
+          connectorId: connector.id,
+          capability: connectionType,
+          status: "authorized"
+        });
+        const [only] = connections;
+        if (connections.length === 1 && only) {
+          await draftApi.upsertConnection(draftId, {
+            connectorId: connector.id,
+            connectionType,
+            connectionId: only.id
+          });
+          bound.push({
+            connectorId: connector.id,
+            connectionType,
+            connectionId: only.id,
+            mode: "auto"
+          });
+          continue;
+        }
+        unresolved.push({
+          connectorId: connector.id,
+          connectionType,
+          reason: connections.length === 0 ? "no_connection" : "multiple_connections",
+          candidateConnectionIds: connections.map((connection) => connection.id)
+        });
+      }
+    }
+  }
+  const { isValid, missing } = await draftApi.getConnectionStatus(draftId);
+  return { action: "connected", draftId, bound, unresolved, isValid, missing };
+}
+function describeRequired(required2) {
+  if (required2.size === 0)
+    return "none";
+  return [...required2].map(([connectorId, types]) => `${connectorId} (${[...types].join(", ")})`).join(", ");
+}
+
+// ../../packages/sdk/dist/esm/drafts/manifest-diff.js
+function stableStringify(value) {
+  return JSON.stringify(sortKeys(value));
+}
+function isDeepEqual(left, right) {
+  return stableStringify(left) === stableStringify(right);
+}
+function diffManifests(before, after) {
+  const previous = asManifest(before);
+  const next = asManifest(after);
+  const changedProperties = [.../* @__PURE__ */ new Set([...Object.keys(previous), ...Object.keys(next)])].filter((key) => key !== "steps").filter((key) => !isDeepEqual(previous[key], next[key])).sort();
+  const previousSteps = stepsById(previous.steps);
+  const nextSteps = stepsById(next.steps);
+  const added = [...nextSteps.keys()].filter((id) => !previousSteps.has(id));
+  const removed = [...previousSteps.keys()].filter((id) => !nextSteps.has(id));
+  const changed = [...nextSteps].filter(([id, step]) => previousSteps.has(id) && !isDeepEqual(previousSteps.get(id), step)).map(([id]) => id);
+  const sharedBefore = [...previousSteps.keys()].filter((id) => nextSteps.has(id));
+  const sharedAfter = [...nextSteps.keys()].filter((id) => previousSteps.has(id));
+  const reordered = sharedBefore.some((id, index) => sharedAfter[index] !== id);
+  return {
+    changedProperties,
+    steps: { added, removed, changed, reordered },
+    isEmpty: changedProperties.length === 0 && added.length === 0 && removed.length === 0 && changed.length === 0 && !reordered
+  };
+}
+function asManifest(value) {
+  return isManifestRecord(value) ? value : {};
+}
+function stepsById(steps) {
+  const byId = /* @__PURE__ */ new Map();
+  if (!Array.isArray(steps))
+    return byId;
+  steps.forEach((step, index) => {
+    const id = isManifestRecord(step) && typeof step.id === "string" ? step.id : `#${index}`;
+    byId.set(id, step);
+  });
+  return byId;
+}
+function sortKeys(value) {
+  if (Array.isArray(value))
+    return value.map(sortKeys);
+  if (!isManifestRecord(value))
+    return value;
+  return Object.fromEntries(Object.keys(value).sort().map((key) => [key, sortKeys(value[key])]));
+}
+
+// ../../packages/sdk/dist/esm/drafts/publish-draft.js
+async function publishDraft(draftApi, { draftId, confirmed }) {
+  const { summary, manifest } = await summarizeForPublish(draftApi, draftId);
+  if (!confirmed) {
+    return { action: "publish_preview", summary };
+  }
+  let published;
+  try {
+    published = await draftApi.finalize(draftId);
+  } catch (error62) {
+    const notReady = getDraftNotReadyError(error62);
+    if (!notReady)
+      throw error62;
+    throw new DraftWorkflowError("draft_not_ready", notReady.message, {
+      draftId,
+      cause: error62
+    });
+  }
+  let automation;
+  try {
+    automation = await draftApi.getAutomation(published.automation.id);
+  } catch (error62) {
+    return {
+      action: "published",
+      summary,
+      automation: published.automation,
+      verification: { status: "unavailable", reason: getErrorMessage(error62) }
+    };
+  }
+  const expected = normaliseManifest(manifest);
+  const actual = normaliseManifest(automation.manifest);
+  return {
+    action: "published",
+    summary,
+    automation,
+    verification: isDeepEqual(expected, actual) ? { status: "matched" } : { status: "mismatched", mismatch: diffManifests(expected, actual) }
+  };
+}
+async function summarizeForPublish(draftApi, draftId) {
+  const [detail, connections] = await Promise.all([
+    draftApi.get(draftId),
+    draftApi.getConnectionStatus(draftId)
+  ]);
+  const { draft } = detail;
+  const target = toDraftTarget(draft);
+  const published = target.kind === "automation" ? await draftApi.getAutomation(target.automationId) : null;
+  const diff = published ? diffManifests(normaliseManifest(published.manifest), normaliseManifest(draft.partialManifest)) : null;
+  const summary = {
+    draftId,
+    name: readManifestName(draft.partialManifest),
+    scope: draft.workspaceId === null ? { kind: "personal" } : {
+      kind: "workspace",
+      workspaceId: draft.workspaceId,
+      // A new workspace automation publishes team-visible; an
+      // edit keeps whatever the automation already has.
+      visibility: published?.visibility ?? "workspace"
+    },
+    target,
+    enabled: published?.enabled ?? true,
+    validation: { state: detail.state, issues: detail.issues },
+    connections: {
+      isValid: connections.isValid,
+      connected: connections.connected.map(({ connectorId, connectionType, connectionId }) => ({
+        connectorId,
+        connectionType,
+        connectionId
+      })),
+      missing: connections.missing
+    },
+    schedule: describeSchedule(draft.partialManifest),
+    diff
+  };
+  return { summary, manifest: draft.partialManifest };
+}
+function describeSchedule(manifest) {
+  if (!hasTriggerType(manifest))
+    return null;
+  const schedule = getManifestTriggers(manifest).find((trigger) => trigger.type === "schedule");
+  if (!schedule || schedule.type !== "schedule")
+    return null;
+  return getScheduleTriggerDescription({ value: schedule.value, timeFormat: "24h" });
+}
+function normaliseManifest(manifest) {
+  const parsed = manifestSchema.safeParse(manifest);
+  return parsed.success ? parsed.data : manifest;
+}
+function readManifestName(manifest) {
+  if (!isManifestRecord(manifest))
+    return "(unnamed)";
+  const { name } = manifest;
+  return typeof name === "string" && name.trim() ? name : "(unnamed)";
+}
+
 // src/lib/auth-environment.ts
 import { InvalidArgumentError } from "commander";
 var ENVIRONMENTS = {
@@ -32935,7 +33402,7 @@ function createAutomationsTokenStore(options = {}) {
 }
 
 // src/lib/credentials.ts
-import { CliError, getConfigPath as getConfigPath3, getErrorMessage as getErrorMessage3 } from "@doist/cli-core";
+import { CliError, getConfigPath as getConfigPath3, getErrorMessage as getErrorMessage4 } from "@doist/cli-core";
 import { refreshAccessToken } from "@doist/cli-core/auth";
 
 // src/lib/auth-scopes.ts
@@ -33025,7 +33492,7 @@ function formatScopesHelp() {
 }
 
 // src/lib/auth-provider.ts
-import { getErrorMessage } from "@doist/cli-core";
+import { getErrorMessage as getErrorMessage2 } from "@doist/cli-core";
 import { createPkceProvider } from "@doist/cli-core/auth";
 var ERROR_HINTS = ["Try again: tda auth login"];
 function createAutomationsAuthProvider() {
@@ -33065,7 +33532,7 @@ async function fetchTodoistUser(token, todoistApiUrl) {
     });
   } catch (error62) {
     throw new Error(
-      `Could not reach Todoist to identify the account: ${getErrorMessage(error62)}`
+      `Could not reach Todoist to identify the account: ${getErrorMessage2(error62)}`
     );
   }
   if (!response.ok) {
@@ -33078,7 +33545,7 @@ async function fetchTodoistUser(token, todoistApiUrl) {
     user = await response.json();
   } catch (error62) {
     throw new Error(
-      `Todoist returned an unreadable identity response: ${getErrorMessage(error62)}`
+      `Todoist returned an unreadable identity response: ${getErrorMessage2(error62)}`
     );
   }
   return { id: requireUserId(user.id), email: typeof user.email === "string" ? user.email : "" };
@@ -33090,13 +33557,13 @@ function requireUserId(id) {
 }
 
 // src/lib/errors.ts
-import { getErrorMessage as getErrorMessage2 } from "@doist/cli-core";
+import { getErrorMessage as getErrorMessage3 } from "@doist/cli-core";
 function getErrorCode(error62) {
   return typeof error62 === "object" && error62 !== null && "code" in error62 ? String(error62.code) : void 0;
 }
 function formatError2(error62) {
   const hints = errorHints(error62);
-  return [getErrorMessage2(error62), ...hints.map((hint) => `  - ${hint}`)].join("\n");
+  return [getErrorMessage3(error62), ...hints.map((hint) => `  - ${hint}`)].join("\n");
 }
 function errorHints(error62) {
   if (typeof error62 !== "object" || error62 === null || !("hints" in error62)) return [];
@@ -33176,7 +33643,7 @@ function accessTokenAfterFailedRefresh(error62, snapshot) {
       if (hasTokenLifeLeft(snapshot)) return snapshot.bundle.accessToken;
       throw new CredentialError(
         "REFRESH_FAILED",
-        `Could not refresh your access token: ${getErrorMessage3(error62)}`,
+        `Could not refresh your access token: ${getErrorMessage4(error62)}`,
         ["Check your network connection and try again."]
       );
   }
@@ -33204,19 +33671,19 @@ function resolveAfterStoreFailure(error62) {
   if (code !== "AUTH_STORE_READ_FAILED") {
     throw new CredentialError(
       "CREDENTIAL_UNREADABLE",
-      `Could not read the stored credential: ${getErrorMessage3(error62)}`,
+      `Could not read the stored credential: ${getErrorMessage4(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(error62)}). Using ${TOKEN_ENV_VAR}.
+      `Warning: could not read the stored credential (${getErrorMessage4(error62)}). Using ${TOKEN_ENV_VAR}.
 `
     );
     return fallback;
   }
-  throw new CredentialError("CREDENTIAL_UNREADABLE", getErrorMessage3(error62), [
+  throw new CredentialError("CREDENTIAL_UNREADABLE", getErrorMessage4(error62), [
     `Set ${TOKEN_ENV_VAR} to bypass the credential store.`,
     "Or re-run `tda auth login --credential-store plaintext`."
   ]);
@@ -33879,7 +34346,7 @@ function attachAutomationsLoginCommand(auth) {
 }
 
 // src/commands/auth/logout.ts
-import { getErrorMessage as getErrorMessage4 } from "@doist/cli-core";
+import { getErrorMessage as getErrorMessage5 } from "@doist/cli-core";
 import { attachLogoutCommand } from "@doist/cli-core/auth";
 
 // src/lib/spinner.ts
@@ -33927,7 +34394,7 @@ async function revokeToken(token) {
     });
     return response.ok ? void 0 : `HTTP ${response.status}`;
   } catch (error62) {
-    return getErrorMessage4(error62);
+    return getErrorMessage5(error62);
   }
 }
 
@@ -34058,7 +34525,7 @@ function parsePositiveInteger(value) {
 }
 
 // src/lib/command-error.ts
-import { formatJson as formatJson4, formatNdjson as formatNdjson4, getErrorMessage as getErrorMessage5 } from "@doist/cli-core";
+import { formatJson as formatJson4, formatNdjson as formatNdjson4, getErrorMessage as getErrorMessage6 } from "@doist/cli-core";
 
 // src/lib/billing-errors.ts
 import { CliError as CliError2 } from "@doist/cli-core";
@@ -34137,7 +34604,7 @@ function renderFailure(error62, context = {}) {
   const explained = explainBillingFailure(authExplained);
   const code = getErrorCode(explained);
   return {
-    message: getErrorMessage5(explained),
+    message: getErrorMessage6(explained),
     humanMessage: formatError2(explained),
     ...code ? { code } : {}
   };
@@ -34168,7 +34635,9 @@ async function runApiCommand(command, operation, presentation, execution = {}) {
   try {
     const globalOptions = getGlobalOptions(command);
     mode = getOutputMode(globalOptions);
-    const apiConfiguration = await resolveApiConfiguration(globalOptions);
+    const apiConfiguration = await resolveApiConfiguration(globalOptions, {
+      minimumTokenLifetimeMs: execution.minimumTokenLifetimeMs
+    });
     source = apiConfiguration.source;
     const context = {
       api: createAutomationsApi(apiConfiguration),
@@ -34184,6 +34653,8 @@ async function runApiCommand(command, operation, presentation, execution = {}) {
     );
     stopEarlySpinner();
     writeResult(mode, result, presentation);
+    const exitCode = execution.exitCode?.(result);
+    if (exitCode !== void 0) process.exitCode = exitCode;
   } catch (error62) {
     if (abortController.signal.aborted) {
       writeFailure(mode, "interrupted", {
@@ -34351,16 +34822,21 @@ function formatRun(run) {
     `Failure reason: ${getRunOutcomeReason(run) ?? "none"}`,
     `Result: ${run.result?.text ?? "none"}`,
     `Steps: ${run.steps.length}`,
-    ...isInsufficientCredit(run) ? ["", topUpAdvisory()] : []
+    ...isInsufficientCredit(run) ? ["", topUpAdvisory()] : [],
+    ...formatRunSteps(run.steps)
   ];
-  for (const [index, step] of run.steps.entries()) {
+  return lines.join("\n");
+}
+function formatRunSteps(steps, { toolCallLabel = "Tool" } = {}) {
+  const lines = [];
+  for (const [index, step] of steps.entries()) {
     lines.push("", `${index + 1}. ${step.stepId} [${step.status}] ${step.description}`);
     lines.push(`   Type: ${step.type}`);
     if (step.startedAt) lines.push(`   Started: ${step.startedAt}`);
     if (step.completedAt) lines.push(`   Completed: ${step.completedAt}`);
     if (step.error) lines.push(`   Error: ${step.error}`);
     for (const toolCall of step.toolCalls ?? []) {
-      lines.push(`   Tool: ${toolCall.name} (${toolCall.id})`);
+      lines.push(`   ${toolCallLabel}: ${toolCall.name} (${toolCall.id})`);
       if (toolCall.argumentKeys.length > 0) {
         lines.push(`     Args: ${toolCall.argumentKeys.join(", ")}`);
       }
@@ -34370,7 +34846,7 @@ function formatRun(run) {
       if (toolCall.resultPreview) lines.push(`     Result preview: ${toolCall.resultPreview}`);
     }
   }
-  return lines.join("\n");
+  return lines;
 }
 function getResourceName(manifest) {
   if (!isRecord2(manifest)) return "(unnamed)";
@@ -36786,7 +37262,7 @@ function registerConnectorCommand(program) {
 }
 
 // src/lib/manifest-input.ts
-import { CliError as CliError3, getErrorMessage as getErrorMessage6 } from "@doist/cli-core";
+import { CliError as CliError3, getErrorMessage as getErrorMessage7 } from "@doist/cli-core";
 import { Option as Option6 } from "commander";
 import { readFile as readFile2 } from "node:fs/promises";
 import { text } from "node:stream/consumers";
@@ -36802,20 +37278,10 @@ async function readManifestInput(options, input2 = process.stdin) {
   } catch (error62) {
     throw new CliError3(
       "MANIFEST_UNREADABLE",
-      `${source.label} is not valid JSON: ${getErrorMessage6(error62)}`
+      `${source.label} is not valid JSON: ${getErrorMessage7(error62)}`
     );
   }
 }
-function parsePartialManifestInput(value) {
-  const validation = validatePartialManifest(value);
-  if (!validation.isValid) {
-    throw new CliError3(
-      "MANIFEST_INVALID",
-      `Manifest is invalid: ${validation.errors.join("; ")}`
-    );
-  }
-  return validation.data;
-}
 async function readSource(options, input2) {
   if (options.file !== void 0) {
     try {
@@ -36823,7 +37289,7 @@ async function readSource(options, input2) {
     } catch (error62) {
       throw new CliError3(
         "MANIFEST_UNREADABLE",
-        `Could not read ${options.file}: ${getErrorMessage6(error62)}`
+        `Could not read ${options.file}: ${getErrorMessage7(error62)}`
       );
     }
   }
@@ -36833,7 +37299,7 @@ async function readSource(options, input2) {
     } catch (error62) {
       throw new CliError3(
         "MANIFEST_UNREADABLE",
-        `Could not read standard input: ${getErrorMessage6(error62)}`
+        `Could not read standard input: ${getErrorMessage7(error62)}`
       );
     }
   }
@@ -36841,124 +37307,56 @@ async function readSource(options, input2) {
 }
 
 // src/commands/draft/draft-service.ts
-import { CliError as CliError4, getErrorMessage as getErrorMessage7 } from "@doist/cli-core";
-
-// src/lib/manifest-diff.ts
-function stableStringify(value) {
-  return JSON.stringify(sortKeys(value));
-}
-function isDeepEqual(left, right) {
-  return stableStringify(left) === stableStringify(right);
+import { CliError as CliError4, getErrorMessage as getErrorMessage8 } from "@doist/cli-core";
+import { readFile as readFile3 } from "node:fs/promises";
+import { setTimeout as wait2 } from "node:timers/promises";
+function createDraft2(draftApi, input2) {
+  return withRecoveryHints(draftApi, createDraft(draftApi, input2));
 }
-function diffManifests(before, after) {
-  const previous = asManifest(before);
-  const next = asManifest(after);
-  const changedProperties = [.../* @__PURE__ */ new Set([...Object.keys(previous), ...Object.keys(next)])].filter((key) => key !== "steps").filter((key) => !isDeepEqual(previous[key], next[key])).sort();
-  const previousSteps = stepsById(previous.steps);
-  const nextSteps = stepsById(next.steps);
-  const added = [...nextSteps.keys()].filter((id) => !previousSteps.has(id));
-  const removed = [...previousSteps.keys()].filter((id) => !nextSteps.has(id));
-  const changed = [...nextSteps].filter(([id, step]) => previousSteps.has(id) && !isDeepEqual(previousSteps.get(id), step)).map(([id]) => id);
-  const sharedBefore = [...previousSteps.keys()].filter((id) => nextSteps.has(id));
-  const sharedAfter = [...nextSteps.keys()].filter((id) => previousSteps.has(id));
-  const reordered = sharedBefore.some((id, index) => sharedAfter[index] !== id);
-  return {
-    changedProperties,
-    steps: { added, removed, changed, reordered },
-    isEmpty: changedProperties.length === 0 && added.length === 0 && removed.length === 0 && changed.length === 0 && !reordered
-  };
+function updateDraft2(draftApi, input2) {
+  return withRecoveryHints(draftApi, updateDraft(draftApi, input2));
 }
-function asManifest(value) {
-  return isRecord3(value) ? value : {};
+function connectDraft2(draftApi, input2) {
+  return withRecoveryHints(draftApi, connectDraft(draftApi, input2));
 }
-function stepsById(steps) {
-  const byId = /* @__PURE__ */ new Map();
-  if (!Array.isArray(steps)) return byId;
-  steps.forEach((step, index) => {
-    const id = isRecord3(step) && typeof step.id === "string" ? step.id : `#${index}`;
-    byId.set(id, step);
-  });
-  return byId;
-}
-function sortKeys(value) {
-  if (Array.isArray(value)) return value.map(sortKeys);
-  if (!isRecord3(value)) return value;
-  return Object.fromEntries(
-    Object.keys(value).sort().map((key) => [key, sortKeys(value[key])])
-  );
-}
-function isRecord3(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-// src/commands/draft/draft-service.ts
-function resolveDraftApi(api, workspaceId, signal) {
-  const createOptions = { signal, translate: false };
-  if (workspaceId === null) {
-    return {
-      scope: null,
-      get: (draftId) => api.automationDrafts.get(draftId, { signal }),
-      create: (manifest) => api.automationDrafts.create(manifest, createOptions),
-      update: (draftId, manifest) => api.automationDrafts.update(draftId, manifest, { signal }),
-      createAutomationDraft: (automationId) => api.automations.createDraft(automationId, { signal }),
-      upsertConnection: (draftId, body) => api.automationDraftConnections.upsert(draftId, body, { signal }),
-      getConnectionStatus: async (draftId) => (await api.automationDraftConnections.getStatus(draftId, { signal })).validation,
-      finalize: (draftId) => api.automationDrafts.finalize(draftId, { signal }),
-      getAutomation: (automationId) => api.automations.get(automationId, { signal })
-    };
-  }
+async function publishDraft2(draftApi, input2) {
+  const result = await withRecoveryHints(draftApi, publishDraft(draftApi, input2));
+  if (result.action === "publish_preview") return result;
+  const { verification } = result;
+  if (verification.status !== "unavailable") return { ...result, verification };
   return {
-    scope: workspaceId,
-    get: (draftId) => api.workspaceAutomationDrafts.get(workspaceId, draftId, { signal }),
-    create: (manifest) => api.workspaceAutomationDrafts.create(workspaceId, manifest, createOptions),
-    update: (draftId, manifest) => api.workspaceAutomationDrafts.update(workspaceId, draftId, manifest, { signal }),
-    createAutomationDraft: (automationId) => api.workspaceAutomations.createDraft(workspaceId, automationId, { signal }),
-    upsertConnection: (draftId, body) => api.workspaceAutomationDraftConnections.upsert(workspaceId, draftId, body, { signal }),
-    getConnectionStatus: async (draftId) => (await api.workspaceAutomationDraftConnections.getStatus(workspaceId, draftId, {
-      signal
-    })).validation,
-    finalize: (draftId) => api.workspaceAutomationDrafts.finalize(workspaceId, draftId, { signal }),
-    getAutomation: (automationId) => api.workspaceAutomations.get(workspaceId, automationId, { signal })
+    ...result,
+    verification: {
+      ...verification,
+      command: `tda automation view ${result.automation.id} ${scopeFlag(draftApi.workspaceId)}`
+    }
   };
 }
-async function createDraft(draftApi, { manifest, automationId }) {
-  const partialManifest = parsePartialManifestInput(manifest);
-  if (automationId === void 0) {
-    const result = await draftApi.create(partialManifest);
-    return { action: "created", target: toTarget(result.draft), ...result };
-  }
-  const { draft } = await openEditDraft(draftApi, automationId);
+async function withRecoveryHints(draftApi, operation) {
   try {
-    const result = await draftApi.update(draft.id, partialManifest);
-    return { action: "created", target: toTarget(result.draft), ...result };
+    return await operation;
   } catch (error62) {
-    if (!isManifestRejection(error62)) throw error62;
-    throw new CliError4(
-      "DRAFT_MANIFEST_REJECTED",
-      `Opened draft ${draft.id} for automation ${automationId}, but the manifest was rejected: ${getErrorMessage7(error62)}`,
-      { hints: draftHints(draftApi.scope, draft.id) }
-    );
-  }
-}
-function isManifestRejection(error62) {
-  return error62 instanceof AutomationsRequestError && (error62.httpStatusCode === 400 || error62.httpStatusCode === 422);
-}
-async function updateDraft(draftApi, { draftId, manifest }) {
-  const partialManifest = parsePartialManifestInput(manifest);
-  const result = await draftApi.update(draftId, partialManifest);
-  return { action: "updated", target: toTarget(result.draft), ...result };
-}
-async function openEditDraft(draftApi, automationId) {
-  try {
-    return await draftApi.createAutomationDraft(automationId);
-  } catch (error62) {
-    const conflict = getOpenDraftConflictError(error62);
-    if (!conflict) throw error62;
-    throw new CliError4(
-      "DRAFT_CONFLICT",
-      `Automation ${automationId} already has an open draft ${conflict.draftId}.`,
-      { hints: draftHints(draftApi.scope, conflict.draftId) }
-    );
+    if (!(error62 instanceof DraftWorkflowError)) throw error62;
+    const scope = draftApi.workspaceId;
+    const draftId = error62.draftId ?? "<draft-id>";
+    switch (error62.code) {
+      case "manifest_invalid":
+        throw new CliError4("MANIFEST_INVALID", error62.message);
+      case "draft_conflict":
+        throw new CliError4("DRAFT_CONFLICT", error62.message, {
+          hints: draftHints(scope, draftId)
+        });
+      case "draft_manifest_rejected":
+        throw new CliError4("DRAFT_MANIFEST_REJECTED", error62.message, {
+          hints: draftHints(scope, draftId)
+        });
+      case "draft_not_ready":
+        throw draftNotReadyError(error62.message, draftId, scope);
+      case "connector_not_required":
+        throw new Error(error62.message);
+      default:
+        throw error62;
+    }
   }
 }
 function draftHints(scope, draftId) {
@@ -36970,172 +37368,135 @@ function draftHints(scope, draftId) {
 function scopeFlag(scope) {
   return scope === null ? "--personal" : `--workspace ${scope}`;
 }
-function toTarget(draft) {
-  return draft.automationId === null ? { kind: "new" } : { kind: "automation", automationId: draft.automationId };
-}
-async function connectDraft(draftApi, api, {
+var DEFAULT_POLL_INTERVALS_MS = { first: 2e3, max: 1e4 };
+var STATUS_REQUEST_GRACE_MS = 1e4;
+var OPEN_RUN_STATUSES = /* @__PURE__ */ new Set([
+  "pending",
+  "running"
+]);
+async function startDraftTest(draftApi, {
   draftId,
-  selections,
-  auto
+  request: request2,
+  wait: waitFor,
+  signal
 }) {
-  const bound = [];
-  const required2 = selections.length > 0 ? getRequiredConnectorsFromManifest(
-    (await draftApi.get(draftId)).draft.partialManifest
-  ) : /* @__PURE__ */ new Map();
-  for (const selection of selections) {
-    const types = required2.get(selection.connectorId);
-    if (!types || selection.connectionType && !types.has(selection.connectionType)) {
-      const slot = selection.connectionType ? `${selection.connectorId} (${selection.connectionType})` : selection.connectorId;
-      throw new Error(
-        `Connector ${slot} is not used by draft ${draftId}. Required: ${describeRequired(required2)}.`
+  let started;
+  try {
+    started = await draftApi.test(draftId, request2);
+  } catch (error62) {
+    const refusal = getDraftTestRequestError(error62);
+    if (!refusal) throw error62;
+    throw toDraftTestCliError(refusal, draftId, draftApi.workspaceId);
+  }
+  const base = {
+    draftId,
+    testRunId: started.testRunId,
+    trigger: started.trigger,
+    connectorCalls: started.connectorCalls,
+    command: `tda draft test-run ${draftId} ${started.testRunId} ${scopeFlag(draftApi.workspaceId)}`
+  };
+  if (!waitFor) {
+    return { action: "test_started", ...base, status: started.status };
+  }
+  const intervals = waitFor.pollIntervalsMs ?? DEFAULT_POLL_INTERVALS_MS;
+  const deadline = Date.now() + waitFor.timeoutMs;
+  let intervalMs = intervals.first;
+  let last = null;
+  while (true) {
+    const requestTimeout = AbortSignal.timeout(
+      Math.max(deadline - Date.now(), 0) + (waitFor.requestGraceMs ?? STATUS_REQUEST_GRACE_MS)
+    );
+    try {
+      last = await draftApi.getTestRun(
+        draftId,
+        started.testRunId,
+        void 0,
+        AbortSignal.any([signal, requestTimeout])
       );
+    } catch (error62) {
+      if (signal.aborted || !requestTimeout.aborted) throw error62;
+      return toFinished(base, last, "timed_out");
     }
-    const connectionTypes = selection.connectionType ? [selection.connectionType] : [...types];
-    for (const connectionType of connectionTypes) {
-      await draftApi.upsertConnection(draftId, {
-        connectorId: selection.connectorId,
-        connectionType,
-        connectionId: selection.connectionId
-      });
-      bound.push({ ...selection, connectionType, mode: "explicit" });
+    if (!OPEN_RUN_STATUSES.has(last.status)) {
+      return toFinished(base, last, toOutcome(last.status));
     }
-  }
-  const unresolved = [];
-  if (auto) {
-    const status = await draftApi.getConnectionStatus(draftId);
-    for (const connector of status.connectors) {
-      for (const connectionType of ["mcp", "trigger"]) {
-        const slot = connector[connectionType];
-        if (!slot.required || slot.status !== "missing") continue;
-        const { connections } = await api.connections.list({
-          connectorId: connector.id,
-          capability: connectionType,
-          status: "authorized"
-        });
-        const [only] = connections;
-        if (connections.length === 1 && only) {
-          await draftApi.upsertConnection(draftId, {
-            connectorId: connector.id,
-            connectionType,
-            connectionId: only.id
-          });
-          bound.push({
-            connectorId: connector.id,
-            connectionType,
-            connectionId: only.id,
-            mode: "auto"
-          });
-          continue;
-        }
-        unresolved.push({
-          connectorId: connector.id,
-          connectionType,
-          reason: connections.length === 0 ? "no_connection" : "multiple_connections",
-          candidateConnectionIds: connections.map((connection) => connection.id)
-        });
-      }
+    const remainingMs = deadline - Date.now();
+    if (remainingMs <= 0) {
+      return toFinished(base, last, "timed_out");
     }
+    await wait2(Math.min(intervalMs, remainingMs), void 0, { signal });
+    intervalMs = Math.min(intervalMs * 2, intervals.max);
   }
-  const { isValid, missing } = await draftApi.getConnectionStatus(draftId);
-  return { action: "connected", draftId, bound, unresolved, isValid, missing };
 }
-function describeRequired(required2) {
-  if (required2.size === 0) return "none";
-  return [...required2].map(([connectorId, types]) => `${connectorId} (${[...types].join(", ")})`).join(", ");
+function toFinished(base, run, outcome) {
+  return {
+    action: "test_finished",
+    ...base,
+    outcome,
+    status: run?.status ?? "pending",
+    failedStep: run?.failedStep ?? null,
+    error: run?.failedStep?.error ?? (run ? getRunOutcomeReason(run) : null) ?? (run?.status === "data-expired" ? "Temporal no longer holds this run's history, so its outcome is unknown" : null),
+    result: run?.result ?? null
+  };
+}
+function toOutcome(status) {
+  switch (status) {
+    case "completed":
+      return "passed";
+    case "skipped":
+      return "skipped";
+    case "cancelled":
+      return "cancelled";
+    default:
+      return "failed";
+  }
 }
-async function publishDraft(draftApi, { draftId, confirmed }) {
-  const { summary, manifest } = await summarizeForPublish(draftApi, draftId);
-  if (!confirmed) {
-    return { action: "publish_preview", summary };
+function draftNotReadyError(message, draftId, scope) {
+  const flag = scopeFlag(scope);
+  return new CliError4("DRAFT_NOT_READY", message, {
+    hints: [
+      `See the issues: tda draft view ${draftId} ${flag}`,
+      `Bind connections: tda draft connect ${draftId} --auto ${flag}`
+    ]
+  });
+}
+function toDraftTestCliError(refusal, draftId, scope) {
+  const flag = scopeFlag(scope);
+  switch (refusal.code) {
+    case "draft_test_not_ready":
+      return draftNotReadyError(refusal.message, draftId, scope);
+    case "draft_test_payload_required":
+    case "draft_test_payload_filtered":
+      return new CliError4(refusal.code.toUpperCase(), refusal.message, {
+        hints: [
+          `Test with a real event: tda draft test ${draftId} --trigger <event> --payload-file <path> ${flag}`
+        ]
+      });
+    default:
+      return new CliError4(refusal.code.toUpperCase(), refusal.message);
   }
-  let published;
+}
+function parseTriggerOption(value) {
+  return /^\d+$/.test(value) ? { index: Number(value) } : { event: value };
+}
+async function readTestPayloadFile(path) {
+  let content;
   try {
-    published = await draftApi.finalize(draftId);
+    content = await readFile3(path, "utf8");
   } catch (error62) {
-    const notReady = getDraftNotReadyError(error62);
-    if (!notReady) throw error62;
-    throw new CliError4("DRAFT_NOT_READY", notReady.message, {
-      hints: [
-        `See the issues: tda draft view ${draftId}`,
-        `Bind connections: tda draft connect ${draftId} --auto`
-      ]
-    });
+    throw new CliError4(
+      "PAYLOAD_UNREADABLE",
+      `Could not read ${path}: ${getErrorMessage8(error62)}`
+    );
   }
-  const automationId = published.automation.id;
-  let automation;
   try {
-    automation = await draftApi.getAutomation(automationId);
+    return JSON.parse(content);
   } catch (error62) {
-    return {
-      action: "published",
-      summary,
-      automation: published.automation,
-      verification: {
-        status: "unavailable",
-        reason: getErrorMessage7(error62),
-        command: `tda automation view ${automationId} ${scopeFlag(draftApi.scope)}`
-      }
-    };
+    throw new CliError4(
+      "PAYLOAD_UNREADABLE",
+      `${path} is not valid JSON: ${getErrorMessage8(error62)}`
+    );
   }
-  const expected = normaliseManifest(manifest);
-  const actual = normaliseManifest(automation.manifest);
-  return {
-    action: "published",
-    summary,
-    automation,
-    verification: isDeepEqual(expected, actual) ? { status: "matched" } : { status: "mismatched", mismatch: diffManifests(expected, actual) }
-  };
-}
-async function summarizeForPublish(draftApi, draftId) {
-  const [detail, connections] = await Promise.all([
-    draftApi.get(draftId),
-    draftApi.getConnectionStatus(draftId)
-  ]);
-  const { draft } = detail;
-  const target = toTarget(draft);
-  const published = target.kind === "automation" ? await draftApi.getAutomation(target.automationId) : null;
-  const diff = published ? diffManifests(
-    normaliseManifest(published.manifest),
-    normaliseManifest(draft.partialManifest)
-  ) : null;
-  const summary = {
-    draftId,
-    name: getResourceName(draft.partialManifest),
-    scope: draft.workspaceId === null ? { kind: "personal" } : {
-      kind: "workspace",
-      workspaceId: draft.workspaceId,
-      // A new workspace automation publishes team-visible; an
-      // edit keeps whatever the automation already has.
-      visibility: published?.visibility ?? "workspace"
-    },
-    target,
-    enabled: published?.enabled ?? true,
-    validation: { state: detail.state, issues: detail.issues },
-    connections: {
-      isValid: connections.isValid,
-      connected: connections.connected.map(
-        ({ connectorId, connectionType, connectionId }) => ({
-          connectorId,
-          connectionType,
-          connectionId
-        })
-      ),
-      missing: connections.missing
-    },
-    schedule: describeSchedule(draft.partialManifest),
-    diff
-  };
-  return { summary, manifest: draft.partialManifest };
-}
-function describeSchedule(manifest) {
-  if (!hasTriggerType(manifest)) return null;
-  const schedule = getManifestTriggers(manifest).find((trigger) => trigger.type === "schedule");
-  if (!schedule || schedule.type !== "schedule") return null;
-  return getScheduleTriggerDescription({ value: schedule.value, timeFormat: "24h" });
-}
-function normaliseManifest(manifest) {
-  const parsed = manifestSchema.safeParse(manifest);
-  return parsed.success ? parsed.data : manifest;
 }
 
 // src/commands/draft/format.ts
@@ -37246,6 +37607,72 @@ function describeDiff(diff) {
   if (diff.steps.reordered) parts.push("steps reordered");
   return parts.join("; ");
 }
+var MOCKED_CONNECTOR_CALLS_LINE = "Connector calls: mocked (simulated by a model; nothing was read from or written to your services)";
+function formatDraftTestRun(run) {
+  const reason = getRunOutcomeReason(run);
+  const lines = [
+    `Test run: ${run.id}`,
+    `Draft: ${run.draftId}`,
+    `Automation: ${run.automationId ?? "none (the draft creates a new one)"}`,
+    `Status: ${run.status}`,
+    MOCKED_CONNECTOR_CALLS_LINE,
+    `Created: ${run.createdAt}`,
+    `Updated: ${run.updatedAt}`
+  ];
+  if (run.failedStep) {
+    lines.push(
+      `Failed step: ${run.failedStep.stepId} (${run.failedStep.description})`,
+      `Error: ${run.failedStep.error ?? reason ?? "none reported"}`
+    );
+  } else if (reason) {
+    lines.push(`${run.status === "skipped" ? "Skip" : "Failure"} reason: ${reason}`);
+  }
+  lines.push(
+    `Result: ${run.result?.text ?? "none"}`,
+    `Steps: ${run.steps.length}`,
+    ...formatRunSteps(run.steps, { toolCallLabel: "Tool (mocked)" })
+  );
+  return lines.join("\n");
+}
+var INPUT_SOURCE_LABELS = {
+  schedule: "as a scheduled run",
+  "sample-event": "with the built-in sample event",
+  supplied: "with the supplied payload",
+  empty: "with an empty request body"
+};
+var OUTCOME_LABELS = {
+  passed: "passed",
+  failed: "failed",
+  skipped: "was skipped",
+  cancelled: "was cancelled",
+  timed_out: "did not finish before the timeout"
+};
+function formatDraftTest(result) {
+  const { trigger } = result;
+  const which = trigger.type === "webhook" ? `webhook ${trigger.event}` : trigger.type;
+  const lines = [
+    result.action === "test_started" ? `Started test run ${result.testRunId} for draft ${result.draftId}.` : `Test run ${result.testRunId} for draft ${result.draftId} ${OUTCOME_LABELS[result.outcome]}.`,
+    `Trigger: ${trigger.index} of ${trigger.count} (${which}), ${INPUT_SOURCE_LABELS[trigger.inputSource]}`
+  ];
+  if (result.action === "test_finished") {
+    if (result.outcome === "timed_out") lines.push(`Status: ${result.status}`);
+    if (result.failedStep) {
+      lines.push(
+        `Failed step: ${result.failedStep.stepId} (${result.failedStep.description})`
+      );
+    }
+    if (result.error)
+      lines.push(`${result.outcome === "skipped" ? "Reason" : "Error"}: ${result.error}`);
+    if (result.result) lines.push(`Result: ${result.result.text}`);
+  }
+  lines.push(MOCKED_CONNECTOR_CALLS_LINE, `Details: ${result.command}`);
+  if (trigger.count > 1) {
+    lines.push(
+      `This draft has ${trigger.count} triggers; test another with --trigger <index|event>.`
+    );
+  }
+  return lines.join("\n");
+}
 
 // src/commands/draft/validate-command.ts
 import { CliError as CliError5 } from "@doist/cli-core";
@@ -37300,8 +37727,10 @@ function formatManifestValidation(result) {
 }
 
 // src/commands/draft/index.ts
+var DEFAULT_TEST_WAIT = "10m";
+var TOKEN_LIFETIME_MARGIN_MS = 2 * 60 * 1e3;
 function registerDraftCommand(program) {
-  const draft = program.command("draft").description("Author and inspect automation drafts");
+  const draft = program.command("draft").description("Author, test and inspect automation drafts");
   registerDraftValidateCommand(draft);
   addWorkspaceScopeOptions(
     addCursorPaginationOptions(
@@ -37358,8 +37787,8 @@ function registerDraftCommand(program) {
       command,
       async ({ api, signal }) => {
         const manifest = await readManifestInput(options);
-        const draftApi = resolveDraftApi(api, await resolveWorkspaceScope(options), signal);
-        return createDraft(draftApi, { manifest, automationId: options.automation });
+        const draftApi = bindDraftApi(api, await resolveWorkspaceScope(options), { signal });
+        return createDraft2(draftApi, { manifest, automationId: options.automation });
       },
       { human: formatDraftChange },
       { spinner: "Creating draft..." }
@@ -37374,8 +37803,8 @@ function registerDraftCommand(program) {
       command,
       async ({ api, signal }) => {
         const manifest = await readManifestInput(options);
-        const draftApi = resolveDraftApi(api, await resolveWorkspaceScope(options), signal);
-        return updateDraft(draftApi, { draftId, manifest });
+        const draftApi = bindDraftApi(api, await resolveWorkspaceScope(options), { signal });
+        return updateDraft2(draftApi, { draftId, manifest });
       },
       { human: formatDraftChange },
       { spinner: "Updating draft..." }
@@ -37401,8 +37830,8 @@ function registerDraftCommand(program) {
           );
         }
         const selections = options.connection.map(parseConnectionSelectionOption);
-        const draftApi = resolveDraftApi(api, await resolveWorkspaceScope(options), signal);
-        return connectDraft(draftApi, api, {
+        const draftApi = bindDraftApi(api, await resolveWorkspaceScope(options), { signal });
+        return connectDraft2(draftApi, {
           draftId,
           selections,
           auto: options.auto === true
@@ -37418,13 +37847,70 @@ function registerDraftCommand(program) {
     await runApiCommand(
       command,
       async ({ api, signal }) => {
-        const draftApi = resolveDraftApi(api, await resolveWorkspaceScope(options), signal);
-        return publishDraft(draftApi, { draftId, confirmed: options.yes === true });
+        const draftApi = bindDraftApi(api, await resolveWorkspaceScope(options), { signal });
+        return publishDraft2(draftApi, { draftId, confirmed: options.yes === true });
       },
       { human: formatDraftPublish, json: summarizeDraftPublish },
       { spinner: options.yes === true ? "Publishing..." : "Loading draft..." }
     );
   });
+  addWorkspaceScopeOptions(
+    draft.command("test").description("Start a test run of a draft, with mocked connector calls").argument("<draft-id>", "Draft ID").option("--wait", "Wait for the run to end and exit 1 unless it passed").option(
+      "--timeout <duration>",
+      `How long --wait waits, such as 90s or 15m (default ${DEFAULT_TEST_WAIT})`
+    ).option(
+      "--trigger <index|event>",
+      "The trigger to test: its position in the manifest's triggers, or a webhook event"
+    ).option(
+      "--payload-file <path>",
+      "A JSON event to test with: a webhook trigger's event or an API trigger's body"
+    )
+  ).action(async (draftId, options, command) => {
+    await runApiCommand(
+      command,
+      async ({ api, signal }) => {
+        if (options.timeout !== void 0 && options.wait !== true) {
+          throw new Error("--timeout only applies with --wait.");
+        }
+        const timeoutMs = parseTestTimeout(options.timeout ?? DEFAULT_TEST_WAIT);
+        const draftApi = bindDraftApi(api, await resolveWorkspaceScope(options), { signal });
+        return startDraftTest(draftApi, {
+          draftId,
+          request: {
+            ...options.trigger !== void 0 ? { trigger: parseTriggerOption(options.trigger) } : {},
+            ...options.payloadFile !== void 0 ? { payload: await readTestPayloadFile(options.payloadFile) } : {}
+          },
+          wait: options.wait === true ? { timeoutMs } : null,
+          signal
+        });
+      },
+      { human: formatDraftTest },
+      {
+        spinner: options.wait === true ? "Testing draft..." : "Starting test run...",
+        minimumTokenLifetimeMs: options.wait === true ? tryParseTestTimeout(options.timeout ?? DEFAULT_TEST_WAIT) + TOKEN_LIFETIME_MARGIN_MS : void 0,
+        exitCode: (result) => result.action === "test_finished" && result.outcome !== "passed" ? 1 : void 0
+      }
+    );
+  });
+  addWorkspaceScopeOptions(
+    draft.command("test-run").description("Show a draft's test run with step and failure details").argument("<draft-id>", "Draft ID").argument("<run-id>", "Test run ID").option("--full", "Include raw step results and generated code in machine output")
+  ).action(async (draftId, runId, options, command) => {
+    await runApiCommand(
+      command,
+      async ({ api, signal }) => {
+        const draftApi = bindDraftApi(api, await resolveWorkspaceScope(options), { signal });
+        return draftApi.getTestRun(draftId, runId, {
+          includeGeneratedCode: options.full === true,
+          includeToolCallPreviews: true
+        });
+      },
+      {
+        human: formatDraftTestRun,
+        json: options.full === true ? void 0 : summarizeDraftTestRun
+      },
+      { spinner: "Loading test run..." }
+    );
+  });
   addWorkspaceScopeOptions(
     draft.command("delete").description("Delete a draft after previewing which one it is").argument("<draft-id>", "Draft ID").option("--yes", "Confirm deletion")
   ).action(async (draftId, options, command) => {
@@ -37461,6 +37947,20 @@ function streamDraftList(options, fetchPage) {
     async (args) => summarizeDraftListPage(await fetchPage(args))
   );
 }
+function tryParseTestTimeout(value) {
+  try {
+    return durationStringToMilliseconds(value);
+  } catch {
+    return 0;
+  }
+}
+function parseTestTimeout(value) {
+  try {
+    return durationStringToMilliseconds(value);
+  } catch {
+    throw new Error(`Invalid --timeout ${value}; use a duration such as 90s, 15m or 1h.`);
+  }
+}
 
 // src/commands/run/index.ts
 import { Option as Option7 } from "commander";