@doist/automations-cli 1.27.0 → 1.28.1

package/dist/index.js

@@ -7,7 +7,7 @@ import {
   collectSkillStatus,
   getInstaller,
   updateAllInstalledSkills
-} from "./chunk-ZTBPLXQS.js";
+} from "./chunk-3JSM3SAL.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.27.0",
+  version: "1.28.1",
   description: "Command-line client for Todoist Automations",
   type: "module",
   bin: {
@@ -29192,6 +29192,11 @@ var automationListResponseSchema = external_exports.object({
   data: external_exports.array(automationSchema),
   nextCursor: external_exports.string().nullable()
 });
+var triggerAutomationResponseSchema = external_exports.object({
+  automationId: external_exports.string(),
+  runId: external_exports.string(),
+  status: external_exports.literal("pending")
+});
 var updateAutomationSchema = external_exports.object({
   enabled: external_exports.boolean().optional(),
   manifest: manifestSchema.optional()
@@ -31057,13 +31062,19 @@ var AutomationsRequestError = class extends Error {
    * scope: a challenge can say the grant falls short without saying of what.
    */
   requiredScope;
-  constructor(message, httpStatusCode, responseData, authChallenge2) {
+  /**
+   * The `X-Request-Id` the response carried, which the backend logs the request
+   * under. Undefined in a browser unless the header is exposed by CORS.
+   */
+  requestId;
+  constructor(message, httpStatusCode, responseData, authChallenge2, requestId) {
     super(message);
     this.name = "AutomationsRequestError";
     this.httpStatusCode = httpStatusCode;
     this.responseData = responseData;
     this.authChallenge = authChallenge2;
     this.requiredScope = parseChallengeScope(authChallenge2);
+    this.requestId = requestId;
   }
   isAuthError() {
     return this.httpStatusCode === 401 || this.httpStatusCode === 403;
@@ -31134,7 +31145,7 @@ async function request(args) {
   const data = await readResponseBody(response);
   if (!response.ok) {
     const message = typeof data === "object" && data !== null && "message" in data ? String(data.message) : response.statusText || `Request failed with status ${response.status}`;
-    throw new AutomationsRequestError(message, response.status, data, response.headers.get("WWW-Authenticate") ?? void 0);
+    throw new AutomationsRequestError(message, response.status, data, response.headers.get("WWW-Authenticate") ?? void 0, response.headers.get("X-Request-Id") ?? void 0);
   }
   return data;
 }
@@ -31545,13 +31556,15 @@ var AutomationsClient = class extends BaseClient {
     });
     return createDraftResponseSchema.parse(data);
   }
+  /** Starts a run now. Undefined from an API that predates returning the run. */
   async trigger(id, options) {
     const parsedId = IdSchema.parse(id);
-    await this.request({
+    const data = await this.request({
       method: "POST",
       path: automationsEndpoints.trigger(parsedId),
       options
     });
+    return triggerAutomationResponseSchema.optional().parse(data);
   }
   async test(id, options) {
     const parsedId = IdSchema.parse(id);
@@ -31886,13 +31899,17 @@ var WorkspaceAutomationsClient = class extends BaseClient {
     });
     return automationSchema.parse(data);
   }
-  /** Runs the automation now. The run executes as its creator, not as the caller. */
+  /**
+   * Runs the automation now. The run executes as its creator, not as the caller.
+   * Undefined from an API that predates returning the run.
+   */
   async trigger(workspaceId, id, options) {
-    await this.request({
+    const data = await this.request({
       method: "POST",
       path: workspaceAutomationsEndpoints.trigger(IdSchema.parse(workspaceId), IdSchema.parse(id)),
       options
     });
+    return triggerAutomationResponseSchema.optional().parse(data);
   }
   /**
    * Deletes the automation. Workspace admins may delete another member's
@@ -32802,6 +32819,9 @@ function readManifestMetadata(dto) {
     ...typeof dto.manifest.description === "string" ? { description: dto.manifest.description } : {}
   };
 }
+function readPrimaryTriggerType(dto) {
+  return hasTriggerType(dto.manifest) ? getManifestTriggers(dto.manifest)[0]?.type : void 0;
+}
 function summarizeTrigger(trigger) {
   if (!isManifestRecord(trigger))
     return void 0;
@@ -33301,24 +33321,11 @@ function readManifestName(manifest) {
   return typeof name === "string" && name.trim() ? name : "(unnamed)";
 }
 
-// ../../packages/sdk/dist/esm/drafts/draft-test.js
+// ../../packages/sdk/dist/esm/runs/poll-until-closed.js
 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, request: request2 }) {
-  const started = await draftApi.test(draftId, request2);
-  return {
-    draftId,
-    testRunId: started.testRunId,
-    trigger: started.trigger,
-    connectorCalls: started.connectorCalls,
-    status: started.status
-  };
-}
-async function waitForDraftTest(draftApi, { draftId, testRunId }, { timeoutMs, pollIntervalsMs, requestGraceMs, onPoll, signal }) {
+var OPEN_RUN_STATUSES = /* @__PURE__ */ new Set(["pending", "running"]);
+async function pollUntilClosed(read2, { timeoutMs, pollIntervalsMs, requestGraceMs, onPoll, signal }) {
   const intervals = pollIntervalsMs ?? DEFAULT_POLL_INTERVALS_MS;
   const deadline = Date.now() + timeoutMs;
   let intervalMs = intervals.first;
@@ -33327,24 +33334,57 @@ async function waitForDraftTest(draftApi, { draftId, testRunId }, { timeoutMs, p
   let last = null;
   while (true) {
     try {
-      last = await draftApi.getTestRun(draftId, testRunId, void 0, requestSignal);
+      last = await read2(requestSignal);
     } catch (error62) {
       if (signal.aborted || !requestTimeout.aborted)
         throw error62;
-      return toFinished(last, "timed_out");
+      return { timedOut: true, run: last };
     }
     if (!OPEN_RUN_STATUSES.has(last.status)) {
-      return toFinished(last, toOutcome(last.status));
+      return { timedOut: false, run: last };
     }
     onPoll?.(last);
     const remainingMs = deadline - Date.now();
     if (remainingMs <= 0) {
-      return toFinished(last, "timed_out");
+      return { timedOut: true, run: last };
     }
     await delay(Math.min(intervalMs, remainingMs), signal);
     intervalMs = Math.min(intervalMs * 2, intervals.max);
   }
 }
+function delay(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal.aborted) {
+      reject(signal.reason);
+      return;
+    }
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(signal.reason);
+    };
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+// ../../packages/sdk/dist/esm/drafts/draft-test.js
+async function startDraftTest(draftApi, { draftId, request: request2 }) {
+  const started = await draftApi.test(draftId, request2);
+  return {
+    draftId,
+    testRunId: started.testRunId,
+    trigger: started.trigger,
+    connectorCalls: started.connectorCalls,
+    status: started.status
+  };
+}
+async function waitForDraftTest(draftApi, { draftId, testRunId }, options) {
+  const polled = await pollUntilClosed((requestSignal) => draftApi.getTestRun(draftId, testRunId, void 0, requestSignal), options);
+  return polled.timedOut ? toFinished(polled.run, "timed_out") : toFinished(polled.run, toOutcome(polled.run.status));
+}
 function toDraftTestTriggerSelector(value) {
   if (typeof value === "number")
     return { index: value };
@@ -33371,22 +33411,64 @@ function toOutcome(status) {
       return "failed";
   }
 }
-function delay(ms, signal) {
-  return new Promise((resolve, reject) => {
-    if (signal.aborted) {
-      reject(signal.reason);
-      return;
-    }
-    const onAbort = () => {
-      clearTimeout(timer);
-      reject(signal.reason);
+
+// ../../packages/sdk/dist/esm/runs/run-api.js
+function bindRunApi(api, workspaceId, { signal } = {}) {
+  if (workspaceId === null) {
+    return {
+      workspaceId: null,
+      getAutomation: (automationId) => api.automations.get(automationId, { signal }),
+      trigger: (automationId) => api.automations.trigger(automationId, { signal }),
+      getRun: (automationId, runId, args = {}, requestSignal) => api.automationRuns.get(automationId, runId, args, {
+        signal: requestSignal ?? signal
+      })
     };
-    const timer = setTimeout(() => {
-      signal.removeEventListener("abort", onAbort);
-      resolve();
-    }, ms);
-    signal.addEventListener("abort", onAbort, { once: true });
-  });
+  }
+  return {
+    workspaceId,
+    getAutomation: (automationId) => api.workspaceAutomations.get(workspaceId, automationId, { signal }),
+    trigger: (automationId) => api.workspaceAutomations.trigger(workspaceId, automationId, { signal }),
+    getRun: (automationId, runId, args = {}, requestSignal) => api.workspaceAutomationRuns.get(workspaceId, automationId, runId, args, {
+      signal: requestSignal ?? signal
+    })
+  };
+}
+
+// ../../packages/sdk/dist/esm/runs/run-wait.js
+async function waitForRun(runApi, { automationId, runId }, options) {
+  const polled = await pollUntilClosed((requestSignal) => runApi.getRun(automationId, runId, void 0, requestSignal), options);
+  return polled.timedOut ? toFinished2(polled.run, "timed_out") : toFinished2(polled.run, toOutcome2(polled.run.status));
+}
+function toFinished2(run, outcome) {
+  const failedStep = run ? findFailedStep(run) : null;
+  return {
+    outcome,
+    status: run?.status ?? "pending",
+    failedStep,
+    error: 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 findFailedStep(run) {
+  const step = run.steps.find((candidate) => candidate.status === "failed");
+  return step ? { stepId: step.stepId, description: step.description, error: step.error ?? null } : null;
+}
+function toOutcome2(status) {
+  switch (status) {
+    case "completed":
+    case "skipped":
+    case "cancelled":
+      return status;
+    default:
+      return "failed";
+  }
+}
+
+// ../../packages/sdk/dist/esm/drafts/conversation-draft.js
+async function findConversationDraftId(api, { conversationId, workspaceId, signal }) {
+  const args = { limit: MAX_PAGINATION_LIMIT };
+  const page = workspaceId === null ? await api.automationDrafts.list(args, { signal }) : await api.workspaceAutomationDrafts.list(workspaceId, args, { signal });
+  return page.data.find((draft) => draft.conversationId === conversationId)?.id ?? null;
 }
 
 // src/lib/auth-environment.ts
@@ -34595,172 +34677,6 @@ import { CliError as CliError3 } from "@doist/cli-core";
 // src/lib/command-error.ts
 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";
-var PAYMENT_REQUIRED_CODE = "PAYMENT_REQUIRED";
-var TOP_UP_PATH = "/settings/top-up";
-var TODOIST_SUBSCRIPTION_PATH = "/app/settings/subscription";
-function topUpUrl() {
-  return `${getEnvironment().appUrl}${TOP_UP_PATH}`;
-}
-function todoistSubscriptionUrl() {
-  return `${getEnvironment().todoistAppUrl}${TODOIST_SUBSCRIPTION_PATH}`;
-}
-var topUpHint = () => `Top up at ${topUpUrl()}.`;
-var HINT_BY_DENIAL_CODE = {
-  usage_billing_insufficient_credit: topUpHint,
-  usage_billing_no_billing_account: topUpHint,
-  usage_billing_plan_required: () => `Upgrade at ${todoistSubscriptionUrl()}.`,
-  usage_billing_billing_paused: topUpHint
-};
-var PaymentRequiredError = class extends CliError2 {
-  constructor(message, hints) {
-    super(PAYMENT_REQUIRED_CODE, message, { hints });
-    this.name = "PaymentRequiredError";
-  }
-};
-function explainBillingFailure(error62) {
-  const refusal = getChatBillingRefusal(error62);
-  if (refusal === null) return error62;
-  const hints = refusal.code === void 0 ? [] : [HINT_BY_DENIAL_CODE[refusal.code]()];
-  return new PaymentRequiredError(refusal.message, hints);
-}
-
-// src/lib/output.ts
-import { formatJson as formatJson3, formatNdjson as formatNdjson3 } from "@doist/cli-core";
-import { stripVTControlCharacters } from "node:util";
-function getOutputMode(args) {
-  if (args.json && args.ndjson) {
-    throw new Error("Choose either --json or --ndjson, not both.");
-  }
-  if (args.json) return "json";
-  if (args.ndjson) return "ndjson";
-  return "human";
-}
-function sanitizeTerminalText(value) {
-  return stripVTControlCharacters(value).replace(
-    /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f]/gu,
-    ""
-  );
-}
-function writeResult(mode, result, presentation, stream = process.stdout) {
-  if (mode === "json") {
-    stream.write(`${formatJson3(presentation.json?.(result) ?? result)}
-`);
-    return;
-  }
-  if (mode === "ndjson") {
-    const output3 = formatNdjson3(
-      presentation.ndjson?.(result) ?? [presentation.json?.(result) ?? result]
-    );
-    if (output3) stream.write(`${output3}
-`);
-    return;
-  }
-  const output2 = sanitizeTerminalText(presentation.human(result));
-  stream.write(output2.endsWith("\n") ? output2 : `${output2}
-`);
-}
-async function writeNdjsonItem(item, stream = process.stdout) {
-  if (stream.write(`${formatNdjson3([item])}
-`) !== false) return;
-  await new Promise((resolve) => stream.once("drain", resolve));
-}
-
-// src/lib/command-error.ts
-function renderFailure(error62, context = {}) {
-  const authExplained = context.source ? explainAuthFailure(error62, context.source) : error62;
-  const explained = explainBillingFailure(authExplained);
-  const code = getErrorCode(explained);
-  return {
-    message: getErrorMessage6(explained),
-    humanMessage: formatError2(explained),
-    ...code ? { code } : {}
-  };
-}
-function writeFailure(mode, status, failure2) {
-  const { message, code } = failure2;
-  const result = { status, message, ...code ? { code } : {} };
-  if (mode === "json") {
-    process.stdout.write(`${formatJson4(result)}
-`);
-  } else if (mode === "ndjson") {
-    process.stdout.write(`${formatNdjson4([{ type: status, ...result, terminal: true }])}
-`);
-  } else {
-    const prefix = status === "error" ? "Error: " : "";
-    process.stdout.write(`${prefix}${sanitizeTerminalText(failure2.humanMessage)}
-`);
-  }
-}
-
-// src/lib/api-command.ts
-async function runApiCommand(command, operation, presentation, execution = {}) {
-  let mode = "human";
-  let source;
-  const abortController = new AbortController();
-  const onInterrupt = () => abortController.abort();
-  process.once("SIGINT", onInterrupt);
-  try {
-    const globalOptions = getGlobalOptions(command);
-    mode = getOutputMode(globalOptions);
-    const apiConfiguration = await resolveApiConfiguration(globalOptions, {
-      minimumTokenLifetimeMs: execution.minimumTokenLifetimeMs
-    });
-    source = apiConfiguration.source;
-    const context = {
-      api: createAutomationsApi(apiConfiguration),
-      signal: abortController.signal
-    };
-    if (mode === "ndjson" && execution.streamNdjson) {
-      for await (const item of execution.streamNdjson(context)) await writeNdjsonItem(item);
-      return;
-    }
-    const result = await withSpinner(
-      { text: execution.spinner ?? "Loading..." },
-      () => operation(context)
-    );
-    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",
-        error62 instanceof CliError3 ? renderFailure(error62, { mode, source }) : { message: "Interrupted.", humanMessage: "Interrupted." }
-      );
-      process.exitCode = 130;
-      return;
-    }
-    writeFailure(mode, "error", renderFailure(error62, { mode, source }));
-    process.exitCode = 1;
-  } finally {
-    process.removeListener("SIGINT", onInterrupt);
-  }
-}
-
-// src/lib/workspace-scope.ts
-import { Option } from "commander";
-async function resolveWorkspaceScope(options) {
-  if (options.workspace !== void 0) {
-    return options.workspace;
-  }
-  if (options.personal) {
-    return null;
-  }
-  return getDefaultWorkspaceId();
-}
-function addWorkspaceScopeOptions(command) {
-  return command.addOption(
-    new Option(
-      "--workspace <workspace-id>",
-      "Act on this workspace instead of your personal space"
-    ).conflicts("personal")
-  ).option("--personal", "Act on your personal space, ignoring any pinned workspace");
-}
-
 // ../../packages/sdk/dist/esm/chat-turn/connection-requirements.js
 var CONNECTION_LOOKUP_CONCURRENCY = 4;
 function deduplicateConnectionRequirements(requirements) {
@@ -35169,6 +35085,67 @@ function assertSelectionsUnambiguous(requirements, selections) {
 
 // ../../packages/sdk/dist/esm/chat-turn/transport.js
 import { DefaultChatTransport, readUIMessageStream } from "ai";
+
+// ../../packages/sdk/dist/esm/chat-turn/errors.js
+var ChatTurnError = class extends Error {
+  conversationId;
+  requestId;
+  stage;
+  /** The API's error body, when it refused the request with one. */
+  response;
+  constructor({ conversationId, requestId, stage, cause }) {
+    const response = stage === "request" ? parseChatStreamRequestError(cause) : void 0;
+    super(response?.message ?? (cause instanceof Error ? cause.message : String(cause)), {
+      cause
+    });
+    this.name = "ChatTurnError";
+    this.conversationId = conversationId;
+    this.requestId = requestId;
+    this.stage = stage;
+    this.response = response;
+  }
+  get httpStatus() {
+    return this.response?.statusCode;
+  }
+};
+function parseChatStreamRequestError(error62) {
+  if (!(error62 instanceof Error) || !error62.message.trim().startsWith("{"))
+    return void 0;
+  let body;
+  try {
+    body = JSON.parse(error62.message);
+  } catch {
+    return void 0;
+  }
+  const parsed = chatStreamRequestErrorResponseSchema.safeParse(body);
+  return parsed.success ? parsed.data : void 0;
+}
+function getChatTurnBillingRefusal(error62) {
+  return getChatBillingRefusal(error62 instanceof ChatTurnError ? error62.cause : error62);
+}
+function readFailedRequest(error62) {
+  if (error62 instanceof ChatTurnError) {
+    return {
+      requestId: error62.requestId,
+      ...error62.httpStatus !== void 0 ? { httpStatus: error62.httpStatus } : {}
+    };
+  }
+  if (error62 instanceof AutomationsRequestError) {
+    return {
+      ...error62.requestId ? { requestId: error62.requestId } : {},
+      httpStatus: error62.httpStatusCode
+    };
+  }
+  return {};
+}
+function classifyChatTurnFailure(error62) {
+  const { httpStatus: httpStatus2 } = readFailedRequest(error62);
+  if (httpStatus2 !== void 0)
+    return httpStatus2 < 500 ? "refused" : "broken";
+  return error62 instanceof ChatTurnError || error62 instanceof AutomationsNetworkError ? "broken" : "other";
+}
+
+// ../../packages/sdk/dist/esm/chat-turn/transport.js
 var ChatTurnTransport = class {
   transport;
   constructor({ token, baseUrl, headers, fetch: fetch2 }) {
@@ -35195,39 +35172,62 @@ var ChatTurnTransport = class {
   }
   /** Streams one server turn, reporting incremental text and deduplicated tool state changes. */
   async streamTurn({ conversationId, workspaceId = null, message, signal, onText, onToolActivity }) {
-    const stream = await this.transport.sendMessages({
-      trigger: "submit-message",
-      chatId: conversationId,
-      messageId: void 0,
-      messages: [message],
-      abortSignal: signal,
-      body: { conversationId, workspaceId }
-    });
+    const requestId = globalThis.crypto.randomUUID();
+    const fail = (stage, cause) => signal?.aborted ? cause : new ChatTurnError({ conversationId, requestId, stage, cause });
+    let stream;
+    try {
+      stream = await this.transport.sendMessages({
+        trigger: "submit-message",
+        chatId: conversationId,
+        messageId: void 0,
+        messages: [message],
+        abortSignal: signal,
+        headers: { "X-Request-Id": requestId },
+        body: { conversationId, workspaceId }
+      });
+    } catch (error62) {
+      throw fail("request", error62);
+    }
     let finalMessage;
     let emittedText = "";
     const emittedToolStates = /* @__PURE__ */ new Set();
-    for await (const currentMessage of readUIMessageStream({
-      stream,
-      terminateOnError: true
-    })) {
-      finalMessage = currentMessage;
-      const visibleText = getVisibleText(currentMessage);
-      if (visibleText.startsWith(emittedText)) {
-        const delta = visibleText.slice(emittedText.length);
-        if (delta)
-          onText?.(delta);
-        emittedText = visibleText;
-      }
-      for (const part of currentMessage.parts) {
-        const activity = toToolActivity(part);
-        if (!activity)
-          continue;
-        const key = `${activity.toolCallId}:${activity.state}`;
-        if (emittedToolStates.has(key))
-          continue;
-        emittedToolStates.add(key);
-        onToolActivity?.(activity);
+    let callbackError;
+    const report = (callback) => {
+      try {
+        callback();
+      } catch (error62) {
+        callbackError = { error: error62 };
+        throw error62;
       }
+    };
+    try {
+      for await (const currentMessage of readUIMessageStream({
+        stream,
+        terminateOnError: true
+      })) {
+        finalMessage = currentMessage;
+        const visibleText = getVisibleText(currentMessage);
+        if (visibleText.startsWith(emittedText)) {
+          const delta = visibleText.slice(emittedText.length);
+          if (delta)
+            report(() => onText?.(delta));
+          emittedText = visibleText;
+        }
+        for (const part of currentMessage.parts) {
+          const activity = toToolActivity(part);
+          if (!activity)
+            continue;
+          const key = `${activity.toolCallId}:${activity.state}`;
+          if (emittedToolStates.has(key))
+            continue;
+          emittedToolStates.add(key);
+          report(() => onToolActivity?.(activity));
+        }
+      }
+    } catch (error62) {
+      if (callbackError)
+        throw callbackError.error;
+      throw fail("stream", error62);
     }
     if (!finalMessage) {
       throw new Error("The Automations chat returned an empty response.");
@@ -35246,6 +35246,255 @@ function toToolActivity(part) {
   };
 }
 
+// src/lib/billing-errors.ts
+import { CliError as CliError2 } from "@doist/cli-core";
+var PAYMENT_REQUIRED_CODE = "PAYMENT_REQUIRED";
+var TOP_UP_PATH = "/settings/top-up";
+var TODOIST_SUBSCRIPTION_PATH = "/app/settings/subscription";
+function topUpUrl() {
+  return `${getEnvironment().appUrl}${TOP_UP_PATH}`;
+}
+function todoistSubscriptionUrl() {
+  return `${getEnvironment().todoistAppUrl}${TODOIST_SUBSCRIPTION_PATH}`;
+}
+var topUpHint = () => `Top up at ${topUpUrl()}.`;
+var HINT_BY_DENIAL_CODE = {
+  usage_billing_insufficient_credit: topUpHint,
+  usage_billing_no_billing_account: topUpHint,
+  usage_billing_plan_required: () => `Upgrade at ${todoistSubscriptionUrl()}.`,
+  usage_billing_billing_paused: topUpHint
+};
+var PaymentRequiredError = class extends CliError2 {
+  constructor(message, hints) {
+    super(PAYMENT_REQUIRED_CODE, message, { hints });
+    this.name = "PaymentRequiredError";
+  }
+};
+function explainBillingFailure(error62) {
+  const refusal = getChatTurnBillingRefusal(error62);
+  if (refusal === null) return error62;
+  const hints = refusal.code === void 0 ? [] : [HINT_BY_DENIAL_CODE[refusal.code]()];
+  return new PaymentRequiredError(refusal.message, hints);
+}
+
+// src/lib/output.ts
+import { formatJson as formatJson3, formatNdjson as formatNdjson3 } from "@doist/cli-core";
+import { stripVTControlCharacters } from "node:util";
+function getOutputMode(args) {
+  if (args.json && args.ndjson) {
+    throw new Error("Choose either --json or --ndjson, not both.");
+  }
+  if (args.json) return "json";
+  if (args.ndjson) return "ndjson";
+  return "human";
+}
+function sanitizeTerminalText(value) {
+  return stripVTControlCharacters(value).replace(
+    /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f]/gu,
+    ""
+  );
+}
+function writeResult(mode, result, presentation, stream = process.stdout) {
+  if (mode === "json") {
+    stream.write(`${formatJson3(presentation.json?.(result) ?? result)}
+`);
+    return;
+  }
+  if (mode === "ndjson") {
+    const output3 = formatNdjson3(
+      presentation.ndjson?.(result) ?? [presentation.json?.(result) ?? result]
+    );
+    if (output3) stream.write(`${output3}
+`);
+    return;
+  }
+  const output2 = sanitizeTerminalText(presentation.human(result));
+  stream.write(output2.endsWith("\n") ? output2 : `${output2}
+`);
+}
+async function writeNdjsonItem(item, stream = process.stdout) {
+  if (stream.write(`${formatNdjson3([item])}
+`) !== false) return;
+  await new Promise((resolve) => stream.once("drain", resolve));
+}
+
+// src/lib/command-error.ts
+function renderFailure(error62, context = {}) {
+  const authExplained = context.source ? explainAuthFailure(error62, context.source) : error62;
+  const explained = explainBillingFailure(authExplained);
+  const code = getErrorCode(explained);
+  return {
+    message: getErrorMessage6(explained),
+    humanMessage: formatError2(explained),
+    ...code ? { code } : {}
+  };
+}
+var FALLBACK_FAILURE_CODE = "TDA_COMMAND_FAILED";
+function toFailureRecord(failure2, details) {
+  return {
+    ...details,
+    status: "error",
+    code: failure2.code ?? FALLBACK_FAILURE_CODE,
+    message: failure2.message
+  };
+}
+function writeFailure(mode, status, failure2) {
+  const result = status === "error" ? toFailureRecord(failure2) : { status, ...failure2.code ? { code: failure2.code } : {}, message: failure2.message };
+  if (mode === "json") {
+    process.stdout.write(`${formatJson4(result)}
+`);
+  } else if (mode === "ndjson") {
+    process.stdout.write(`${formatNdjson4([{ type: status, ...result, terminal: true }])}
+`);
+  } else {
+    const prefix = status === "error" ? "Error: " : "";
+    process.stdout.write(`${prefix}${sanitizeTerminalText(failure2.humanMessage)}
+`);
+  }
+}
+
+// src/lib/api-command.ts
+async function runApiCommand(command, operation, presentation, execution = {}) {
+  let mode = "human";
+  let source;
+  const abortController = new AbortController();
+  const onInterrupt = () => abortController.abort();
+  process.once("SIGINT", onInterrupt);
+  try {
+    const globalOptions = getGlobalOptions(command);
+    mode = getOutputMode(globalOptions);
+    const apiConfiguration = await resolveApiConfiguration(globalOptions, {
+      minimumTokenLifetimeMs: execution.minimumTokenLifetimeMs
+    });
+    source = apiConfiguration.source;
+    const outputMode = mode;
+    const context = {
+      api: createAutomationsApi(apiConfiguration),
+      signal: abortController.signal,
+      progress: (record2) => {
+        if (outputMode === "ndjson") void writeNdjsonItem({ ...record2, terminal: false });
+      }
+    };
+    if (mode === "ndjson" && execution.streamNdjson) {
+      for await (const item of execution.streamNdjson(context)) await writeNdjsonItem(item);
+      return;
+    }
+    const result = await withSpinner(
+      { text: execution.spinner ?? "Loading..." },
+      () => operation(context)
+    );
+    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",
+        error62 instanceof CliError3 ? renderFailure(error62, { mode, source }) : { message: "Interrupted.", humanMessage: "Interrupted." }
+      );
+      process.exitCode = 130;
+      return;
+    }
+    writeFailure(mode, "error", renderFailure(error62, { mode, source }));
+    process.exitCode = 1;
+  } finally {
+    process.removeListener("SIGINT", onInterrupt);
+  }
+}
+
+// src/lib/wait-options.ts
+import { CliError as CliError4, getErrorMessage as getErrorMessage7 } from "@doist/cli-core";
+var DEFAULT_WAIT = "10m";
+var TOKEN_LIFETIME_MARGIN_MS = 2 * 60 * 1e3;
+function addWaitOptions(command, waitDescription) {
+  return command.option("--wait", waitDescription).option(
+    "--timeout <duration>",
+    `How long --wait waits, such as 90s or 15m (default ${DEFAULT_WAIT})`
+  );
+}
+function resolveWait(options) {
+  if (options.timeout !== void 0 && options.wait !== true) {
+    throw new Error("--timeout only applies with --wait.");
+  }
+  if (options.wait !== true) {
+    return null;
+  }
+  return { timeoutMs: parseTimeout(options.timeout ?? DEFAULT_WAIT) };
+}
+function waitTokenLifetimeMs(options) {
+  if (options.wait !== true) {
+    return void 0;
+  }
+  try {
+    return parseTimeout(options.timeout ?? DEFAULT_WAIT) + TOKEN_LIFETIME_MARGIN_MS;
+  } catch {
+    return TOKEN_LIFETIME_MARGIN_MS;
+  }
+}
+function parseTimeout(value) {
+  try {
+    return durationStringToMilliseconds(value);
+  } catch {
+    throw new Error(`Invalid --timeout ${value}; use a duration such as 90s, 15m or 1h.`);
+  }
+}
+function reportRunProgress(report) {
+  let last;
+  return (run) => {
+    const step = run.steps.find((candidate) => candidate.status === "running")?.stepId;
+    const key = `${run.status}:${step ?? ""}`;
+    if (key === last) return;
+    last = key;
+    report({ status: run.status, ...step ? { step } : {} });
+  };
+}
+function toRunWaitError(error62, {
+  run,
+  command,
+  codes,
+  signal
+}) {
+  const hints = [`See how it ends: ${command}`];
+  if (signal.aborted) {
+    return new CliError4(codes.interrupted, `Stopped waiting for ${run}. It keeps running.`, {
+      hints
+    });
+  }
+  return new CliError4(
+    codes.failed,
+    `Checking on ${run} failed: ${getErrorMessage7(error62).replace(/\.?$/, ".")} It keeps running.`,
+    { hints }
+  );
+}
+function toTerminalRecords(result) {
+  return [{ type: result.action, ...result, terminal: true }];
+}
+
+// src/lib/workspace-scope.ts
+import { Option } from "commander";
+async function resolveWorkspaceScope(options) {
+  if (options.workspace !== void 0) {
+    return options.workspace;
+  }
+  if (options.personal) {
+    return null;
+  }
+  return getDefaultWorkspaceId();
+}
+function scopeFlag(scope) {
+  return scope === null ? "--personal" : `--workspace ${scope}`;
+}
+function addWorkspaceScopeOptions(command) {
+  return command.addOption(
+    new Option(
+      "--workspace <workspace-id>",
+      "Act on this workspace instead of your personal space"
+    ).conflicts("personal")
+  ).option("--personal", "Act on your personal space, ignoring any pinned workspace");
+}
+
 // src/commands/read/format.ts
 function formatAutomationList(page) {
   if (page.data.length === 0) return "No automations found.";
@@ -35457,8 +35706,35 @@ function describeVisibility(automation) {
 function summarizeAutomationChange(result) {
   return { ...result, automation: summarizeAutomation(result.automation) };
 }
+var RUN_OUTCOME_LABELS = {
+  completed: "completed",
+  failed: "failed",
+  skipped: "was skipped",
+  cancelled: "was cancelled",
+  timed_out: "did not finish before the timeout"
+};
 function formatAutomationTrigger(result) {
-  return `Triggered automation ${result.automationId}.`;
+  if (result.action === "triggered") {
+    if (result.runId === null) {
+      return `Triggered automation ${result.automationId}.`;
+    }
+    return [
+      `Started run ${result.runId} of automation ${result.automationId}.`,
+      `Details: ${result.command}`
+    ].join("\n");
+  }
+  const lines = [
+    `Run ${result.runId} of automation ${result.automationId} ${RUN_OUTCOME_LABELS[result.outcome]}.`
+  ];
+  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(`Details: ${result.command}`);
+  return lines.join("\n");
 }
 function formatAutomationDelete(result) {
   if (result.action === "delete_preview") {
@@ -35473,6 +35749,66 @@ function capitalize(value) {
   return `${value.charAt(0).toUpperCase()}${value.slice(1)}`;
 }
 
+// src/commands/automation/trigger-service.ts
+import { CliError as CliError5 } from "@doist/cli-core";
+async function triggerAutomation(runApi, {
+  automationId,
+  wait: wait2,
+  signal,
+  onProgress
+}) {
+  const triggerType = readPrimaryTriggerType(await runApi.getAutomation(automationId));
+  if (triggerType !== "schedule") {
+    throw new Error(
+      "This automation can only be triggered via its configured mechanism, not manually."
+    );
+  }
+  const started = await runApi.trigger(automationId);
+  const flag = scopeFlag(runApi.workspaceId);
+  if (!started) {
+    if (wait2) {
+      throw new CliError5(
+        "TRIGGER_RUN_UNREPORTED",
+        "The run started, but the API did not say which one it was, so it cannot be waited for.",
+        { hints: [`See the latest run: tda run list ${automationId} --limit 1 ${flag}`] }
+      );
+    }
+    return { action: "triggered", automationId, runId: null, status: null, command: null };
+  }
+  const identity = {
+    automationId,
+    runId: started.runId,
+    command: `tda run view ${automationId} ${started.runId} ${flag}`
+  };
+  if (!wait2) {
+    return { action: "triggered", ...identity, status: started.status };
+  }
+  let finished;
+  try {
+    finished = await waitForRun(runApi, identity, {
+      ...wait2,
+      signal,
+      ...onProgress ? { onPoll: reportRunProgress(onProgress) } : {}
+    });
+  } catch (error62) {
+    throw toRunWaitError(error62, {
+      run: `run ${identity.runId} of automation ${automationId}`,
+      command: identity.command,
+      codes: { interrupted: "TRIGGER_WAIT_INTERRUPTED", failed: "TRIGGER_WAIT_FAILED" },
+      signal
+    });
+  }
+  return {
+    action: "run_finished",
+    ...identity,
+    outcome: finished.outcome,
+    status: finished.status,
+    failedStep: finished.failedStep,
+    error: finished.error,
+    result: finished.result
+  };
+}
+
 // src/commands/automation/index.ts
 function registerAutomationCommand(program) {
   const automation = program.command("automation").description("Inspect and manage published automations");
@@ -35522,30 +35858,29 @@ function registerAutomationCommand(program) {
   registerEnabledStateCommand(automation, "enable", true);
   registerEnabledStateCommand(automation, "disable", false);
   addWorkspaceScopeOptions(
-    automation.command("trigger").description("Start a live automation run without waiting for it to finish").argument("<automation-id>", "Automation ID")
+    addWaitOptions(
+      automation.command("trigger").description("Start a live automation run and print its run ID").argument("<automation-id>", "Automation ID"),
+      "Wait for the run to end and exit 1 unless it completed"
+    )
   ).action(async (automationId, options, command) => {
     await runApiCommand(
       command,
-      async ({ api, signal }) => {
-        const workspaceId = await resolveWorkspaceScope(options);
-        const automation2 = workspaceId === null ? await api.automations.get(automationId, { signal }) : await api.workspaceAutomations.get(workspaceId, automationId, {
-          signal
+      async ({ api, signal, progress }) => {
+        const wait2 = resolveWait(options);
+        const runApi = bindRunApi(api, await resolveWorkspaceScope(options), { signal });
+        return triggerAutomation(runApi, {
+          automationId,
+          wait: wait2,
+          signal,
+          onProgress: (state) => progress({ type: "run_progress", automationId, ...state })
         });
-        const triggerType = hasTriggerType(automation2.manifest) ? getManifestTriggers(automation2.manifest)[0]?.type : void 0;
-        if (triggerType !== "schedule") {
-          throw new Error(
-            "This automation can only be triggered via its configured mechanism, not manually."
-          );
-        }
-        if (workspaceId === null) {
-          await api.automations.trigger(automationId, { signal });
-        } else {
-          await api.workspaceAutomations.trigger(workspaceId, automationId, { signal });
-        }
-        return { action: "triggered", automationId };
       },
-      { human: formatAutomationTrigger },
-      { spinner: "Triggering automation..." }
+      { human: formatAutomationTrigger, ndjson: toTerminalRecords },
+      {
+        spinner: options.wait === true ? "Running automation..." : "Triggering automation...",
+        minimumTokenLifetimeMs: waitTokenLifetimeMs(options),
+        exitCode: (result) => result.action === "run_finished" && result.outcome !== "completed" ? 1 : void 0
+      }
     );
   });
   addWorkspaceScopeOptions(
@@ -35802,6 +36137,7 @@ function collectOption(value, previous) {
 }
 
 // src/commands/chat/chat-service.ts
+import { CliError as CliError7 } from "@doist/cli-core";
 import { createInterface } from "node:readline/promises";
 
 // src/commands/chat/connection-authorizer.ts
@@ -35816,6 +36152,13 @@ var FINAL_EVENT_TYPES = /* @__PURE__ */ new Set([
   "session_status",
   "turn_completed"
 ]);
+var UNRECORDED_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "assistant_text",
+  "connection_authorization_waiting",
+  "turn_progress"
+]);
+var INTERRUPTING_EVENT_TYPES = /* @__PURE__ */ new Set(["error", "interrupted"]);
+var HEARTBEAT_EVENT_TYPES = /* @__PURE__ */ new Set(["connection_authorization_waiting", "turn_progress"]);
 var SPINNER_TEXT = {
   connection_authorization_opened: "Waiting for authorization...",
   connection_authorization_started: "Waiting for authorization...",
@@ -35826,16 +36169,47 @@ var OutputWriter = class {
   stream;
   diagnosticStream;
   events = [];
+  streamText;
   assistantLineOpen = false;
   currentConversationId;
-  constructor(mode, stream = process.stdout, diagnosticStream = process.stderr) {
+  /** The current turn's text, one entry per step. */
+  turnSteps = [];
+  stepOpen = false;
+  bufferedText = "";
+  bufferedTextConversationId;
+  constructor(mode, stream = process.stdout, diagnosticStream = process.stderr, { streamText = false } = {}) {
     this.mode = mode;
     this.stream = stream;
     this.diagnosticStream = diagnosticStream;
+    this.streamText = streamText;
+  }
+  /**
+   * Assistant text as it arrives. A human reader, or an NDJSON caller that
+   * asked with `--stream-text`, gets each fragment as `assistant_text`;
+   * otherwise the text of a step comes out whole as one `assistant_message`
+   * before whatever follows it.
+   */
+  appendAssistantText(conversationId, text2) {
+    if (!this.stepOpen) this.turnSteps.push("");
+    this.stepOpen = true;
+    this.turnSteps[this.turnSteps.length - 1] += text2;
+    if (this.mode === "human" || this.mode === "ndjson" && this.streamText) {
+      this.emit({ type: "assistant_text", conversationId, text: text2 });
+      return;
+    }
+    this.bufferedText += text2;
+    this.bufferedTextConversationId = conversationId;
   }
   /** Records and renders an event; JSON mode retains structured output until `finish`. */
   emit(event) {
-    if (this.mode === "json") this.events.push(event);
+    const endsStep = event.type !== "assistant_message" && event.type !== "assistant_text" && !HEARTBEAT_EVENT_TYPES.has(event.type);
+    if (endsStep) {
+      this.flushAssistantMessage(INTERRUPTING_EVENT_TYPES.has(event.type));
+      this.stepOpen = false;
+    }
+    if (this.mode === "json" && !UNRECORDED_EVENT_TYPES.has(event.type)) {
+      this.events.push(event);
+    }
     if (event.conversationId) this.currentConversationId = event.conversationId;
     if (this.mode === "ndjson") {
       this.stream.write(`${formatNdjson5([event])}
@@ -35851,17 +36225,28 @@ var OutputWriter = class {
   get conversationId() {
     return this.currentConversationId;
   }
+  /** The current turn's text so far, its steps separated by blank lines. */
+  get assistantText() {
+    return this.turnSteps.join("\n\n");
+  }
+  /** Starts collecting the text of a new turn. */
+  startTurn() {
+    this.turnSteps = [];
+    this.stepOpen = false;
+  }
   /** Emits structured conversation status with human formatting owned by this output layer. */
   emitConversationStatus(snapshot, pendingActionKind) {
     this.emit({
       type: "session_status",
       conversationId: snapshot.conversation.id,
       ...snapshot,
-      humanText: formatConversationStatus(snapshot, pendingActionKind)
+      humanText: formatConversationStatus(snapshot, pendingActionKind),
+      terminal: true
     });
   }
   /** Finalizes output, including the accumulated event list in JSON mode. */
   finish(summary) {
+    this.flushAssistantMessage(false);
     stopEarlySpinner();
     if (this.mode === "json") {
       this.stream.write(`${formatJson5({ ...summary, events: this.events })}
@@ -35873,6 +36258,17 @@ var OutputWriter = class {
       this.assistantLineOpen = false;
     }
   }
+  flushAssistantMessage(partial2) {
+    if (!this.bufferedText) return;
+    const text2 = this.bufferedText;
+    this.bufferedText = "";
+    this.emit({
+      type: "assistant_message",
+      conversationId: this.bufferedTextConversationId,
+      text: text2,
+      ...partial2 ? { partial: true } : {}
+    });
+  }
   /**
    * The agent goes quiet for long stretches between events, so a spinner
    * fills the gap. Taking it down before every write keeps its next frame
@@ -36096,6 +36492,7 @@ function getMessageRoleLabel(role) {
 
 // src/commands/chat/connection-authorizer.ts
 var CONNECTION_POLL_INTERVAL_MS = 2e3;
+var CONNECTION_WAITING_REPORT_INTERVAL_MS = 15e3;
 var CONNECTION_AUTHORIZATION_TIMEOUT_MS = 10 * 60 * 1e3;
 var ApiConnectionAuthorizer = class {
   connections;
@@ -36187,6 +36584,7 @@ var ApiConnectionAuthorizer = class {
   }
   async waitUntilAuthorized(request2, connectionId, signal) {
     const startedAt = Date.now();
+    let reportedAt;
     while (true) {
       if (signal?.aborted) throw new Error("Connection authorization interrupted.");
       const connection = await this.connections.get(connectionId, { signal });
@@ -36214,16 +36612,20 @@ var ApiConnectionAuthorizer = class {
           `Timed out waiting for ${request2.serviceName} connection authorization.`
         );
       }
-      this.output.emit({
-        type: "connection_authorization_waiting",
-        conversationId: request2.conversationId,
-        connectionId,
-        connectorId: request2.connectorId,
-        serviceName: request2.serviceName,
-        elapsedSeconds: Math.floor(elapsedMs / 1e3),
-        state: "waiting_for_user",
-        terminal: false
-      });
+      const now = Date.now();
+      if (reportedAt === void 0 || now - reportedAt >= CONNECTION_WAITING_REPORT_INTERVAL_MS) {
+        reportedAt = now;
+        this.output.emit({
+          type: "connection_authorization_waiting",
+          conversationId: request2.conversationId,
+          connectionId,
+          connectorId: request2.connectorId,
+          serviceName: request2.serviceName,
+          elapsedSeconds: Math.floor(elapsedMs / 1e3),
+          state: "waiting_for_user",
+          terminal: false
+        });
+      }
       await wait(Math.min(this.pollIntervalMs, this.timeoutMs - elapsedMs), void 0, {
         signal
       });
@@ -36238,11 +36640,48 @@ function isSafeSetupUrl(value) {
   }
 }
 
+// src/commands/chat/chat-failure.ts
+var SELECTION_CODES = /* @__PURE__ */ new Set([
+  "CHAT_AWAITING_SELECTION",
+  "CHAT_AMBIGUOUS_SELECTION",
+  "CHAT_UNKNOWN_CONNECTION"
+]);
+function chatFailureCode(error62) {
+  switch (classifyChatTurnFailure(error62)) {
+    case "broken":
+      return "CHAT_TURN_FAILED";
+    case "refused":
+      return "CHAT_TURN_REJECTED";
+    default:
+      return FALLBACK_FAILURE_CODE;
+  }
+}
+function messageResumeCommand(conversationId) {
+  return `tda chat continue ${conversationId} "<message>"`;
+}
+function resumeCommandFor(conversationId, code) {
+  if (code === "CHAT_TURN_ACTIVE") return void 0;
+  if (code === "CHAT_AWAITING_PUSH") return `tda chat continue ${conversationId}`;
+  if (SELECTION_CODES.has(code)) {
+    return `tda chat continue ${conversationId} --connection <connector[:type]=connection-id>`;
+  }
+  return messageResumeCommand(conversationId);
+}
+function formatChatFailureDetails(details) {
+  return [
+    `Conversation: ${details.conversationId}`,
+    ...details.requestId ? [`Request ID: ${details.requestId}`] : [],
+    ...details.draftCommand ? [`Its draft is saved: ${details.draftCommand}`] : [],
+    ...details.resumeCommand ? [`Resume with: ${details.resumeCommand}`] : []
+  ];
+}
+
 // 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 } from "node:crypto";
+import { CliError as CliError6 } from "@doist/cli-core";
 var ConversationTurnLock = class {
   directory;
   pid;
@@ -36279,7 +36718,8 @@ var ConversationTurnLock = class {
         }
         const current = await readLock(path);
         if (current && this.isProcessRunning(current.pid)) {
-          throw new Error(
+          throw new CliError6(
+            "CHAT_TURN_ACTIVE",
             `Conversation ${conversationId} already has an active turn in process ${current.pid}. Continue monitoring that process; do not invoke continue until it exits.`
           );
         }
@@ -36326,7 +36766,8 @@ function isNoSuchProcessError(error62) {
 
 // src/commands/chat/chat-service.ts
 var TURN_HEARTBEAT_INTERVAL_MS = 15e3;
-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 DRAFT_LOOKUP_TIMEOUT_MS = 5e3;
+var TURN_RUNNING_MESSAGE = "Keep monitoring this process; do not invoke continue until a record with terminal=true is emitted and the process exits.";
 var ChatService = class {
   api;
   transport;
@@ -36336,6 +36777,8 @@ var ChatService = class {
   turnLock;
   heartbeatIntervalMs;
   readline;
+  /** The conversation a start or continue is working on, once it is known. */
+  failureScope;
   constructor({
     token,
     baseUrl,
@@ -36366,6 +36809,10 @@ var ChatService = class {
    */
   async startConversation(message, signal, workspaceId = null) {
     const conversation = workspaceId === null ? await this.api.chat.createConversation({}, { signal }) : await this.api.workspaceChat.createConversation(workspaceId, {}, { signal });
+    this.failureScope = {
+      conversationId: conversation.id,
+      workspaceId: conversation.workspaceId
+    };
     this.output.emit({ type: "session_started", conversationId: conversation.id });
     return this.withActiveTurn(
       conversation.id,
@@ -36384,8 +36831,10 @@ var ChatService = class {
     selections,
     signal
   }) {
+    this.failureScope = { conversationId };
     const conversation = await this.api.chat.getConversation(conversationId, { signal });
     const scope = { conversationId, workspaceId: conversation.workspaceId };
+    this.failureScope = scope;
     return this.withActiveTurn(
       conversationId,
       async () => {
@@ -36398,7 +36847,8 @@ var ChatService = class {
         } else {
           const nextMessage = this.interactive ? await this.promptForMessage(signal) : "";
           if (!nextMessage) {
-            throw new Error(
+            throw new CliError7(
+              "CHAT_INPUT_REQUIRED",
               "A message or --connection selection is required to continue."
             );
           }
@@ -36504,6 +36954,7 @@ var ChatService = class {
     }
   }
   async runTurn({ conversationId, workspaceId }, input2, signal, pendingAction, { markActivity }) {
+    this.output.startTurn();
     try {
       return await runConversationTurn({
         api: this.api,
@@ -36515,7 +36966,7 @@ var ChatService = class {
         signal,
         onText: (text2) => {
           markActivity();
-          this.output.emit({ type: "assistant_text", conversationId, text: text2 });
+          this.output.appendAssistantText(conversationId, text2);
         },
         onToolActivity: (activity) => {
           markActivity();
@@ -36537,7 +36988,7 @@ var ChatService = class {
       });
     } catch (error62) {
       if (error62 instanceof ChatTurnInputError) {
-        throw new Error(describeInputError(error62));
+        throw new CliError7(`CHAT_${error62.code.toUpperCase()}`, describeInputError(error62));
       }
       throw error62;
     }
@@ -36561,13 +37012,17 @@ var ChatService = class {
       terminal: false
     });
   }
-  completeTurn(summary) {
+  completeTurn(turn) {
+    const summary = { ...turn, assistantText: this.output.assistantText || turn.assistantText };
     const resumeCommand = getResumeCommand(summary);
     this.output.emit({
       type: "turn_completed",
       conversationId: summary.conversationId,
       status: summary.status,
       outcome: summary.status,
+      assistantText: summary.assistantText,
+      ...summary.automationId ? { automationId: summary.automationId } : {},
+      ...summary.action ? { action: summary.action } : {},
       state: "completed",
       terminal: true,
       ...summary.conversationArchived !== void 0 ? { conversationArchived: summary.conversationArchived } : {},
@@ -36608,6 +37063,32 @@ var ChatService = class {
       await release();
     }
   }
+  /** Whether a start or continue has a conversation its failure can name. */
+  get hasFailureScope() {
+    return this.failureScope !== void 0;
+  }
+  /**
+   * What a caller needs to pick up a conversation whose start or continue
+   * failed, or undefined before one was known. The draft is looked up only for
+   * a turn that broke, not one refused for its input, credentials or balance.
+   */
+  async describeFailure(error62, code) {
+    const scope = this.failureScope;
+    if (!scope) return void 0;
+    const { conversationId, workspaceId } = scope;
+    const draftId = workspaceId !== void 0 && classifyChatTurnFailure(error62) === "broken" ? await findConversationDraftId(this.api, {
+      conversationId,
+      workspaceId,
+      signal: AbortSignal.timeout(DRAFT_LOOKUP_TIMEOUT_MS)
+    }).catch(() => null) : null;
+    const resumeCommand = resumeCommandFor(conversationId, code);
+    return {
+      conversationId,
+      ...readFailedRequest(error62),
+      ...draftId && workspaceId !== void 0 ? { draftId, draftCommand: `tda draft view ${draftId} ${scopeFlag(workspaceId)}` } : {},
+      ...resumeCommand ? { resumeCommand } : {}
+    };
+  }
   async getPersistedPendingAction(conversationId, signal) {
     const messages = await this.api.chat.getMessages(conversationId, { signal });
     return getPendingActionFromMessages(messages);
@@ -36694,21 +37175,25 @@ function getResumeCommand(summary) {
   if (typeof actionResume === "string") {
     return actionResume.replace("<conversation-id>", summary.conversationId);
   }
-  return `tda chat continue ${summary.conversationId} "<message>"`;
+  return messageResumeCommand(summary.conversationId);
 }
 
 // src/commands/chat/index.ts
 function registerChatCommand(program) {
   const chat = program.command("chat").description("Talk to the Todoist Automations agent");
   addWorkspaceScopeOptions(
-    chat.command("start").description("Start a new conversation").argument("<message...>", "Initial message")
+    addStreamTextOption(
+      chat.command("start").description("Start a new conversation").argument("<message...>", "Initial message")
+    )
   ).action(async (messageParts, options, command) => {
     await runCommand(command, async ({ service, signal }) => {
       const workspaceId = await resolveWorkspaceScope(options);
       return service.startConversation(messageParts.join(" "), signal, workspaceId);
     });
   });
-  chat.command("continue").description("Continue a persisted conversation").argument("<conversation-id>", "Conversation ID emitted by start").argument("[message...]", "Answer or follow-up message").option(
+  addStreamTextOption(
+    chat.command("continue").description("Continue a persisted conversation").argument("<conversation-id>", "Conversation ID emitted by start").argument("[message...]", "Answer or follow-up message")
+  ).option(
     "--connection <connector[:type]=connection-id>",
     "Resolve a pending connection selection; repeat for multiple connectors",
     collectOption,
@@ -36733,11 +37218,19 @@ function registerChatCommand(program) {
     );
   });
 }
+function addStreamTextOption(command) {
+  return command.option(
+    "--stream-text",
+    "Under --ndjson, emit the assistant text as it arrives (assistant_text) rather than one assistant_message per step"
+  );
+}
 async function runCommand(command, operation) {
   let service;
   let source;
   await runStreamingCommand(command, {
-    createOutput: (mode) => new OutputWriter(mode),
+    createOutput: (mode) => new OutputWriter(mode, process.stdout, process.stderr, {
+      streamText: command.opts().streamText === true
+    }),
     operation: async ({ options, mode, output: output2, signal }) => {
       const apiConfiguration = await withSpinner(
         { text: "Connecting..." },
@@ -36760,33 +37253,33 @@ async function runCommand(command, operation) {
     onSuccess: (result, { output: output2 }) => output2.finish(result),
     onInterrupted: ({ output: output2 }) => {
       const conversationId = output2.conversationId;
-      output2.emit({ type: "interrupted", conversationId });
+      const resume = conversationId ? { resumeCommand: messageResumeCommand(conversationId) } : {};
       output2.emit({
-        type: "turn_completed",
+        type: "interrupted",
         conversationId,
         status: "interrupted",
-        outcome: "interrupted",
-        state: "completed",
-        terminal: true,
-        ...conversationId ? { resumeCommand: `tda chat continue ${conversationId} "<message>"` } : {}
+        message: "Interrupted.",
+        ...resume,
+        terminal: true
       });
       output2.finish({
         conversationId,
         status: "interrupted",
-        assistantText: ""
+        assistantText: output2.assistantText,
+        ...resume
       });
     },
-    onError: (error62, { mode, output: output2 }) => {
+    onError: async (error62, { mode, output: output2 }) => {
       const failure2 = renderFailure(error62, { mode, source });
-      const message = mode === "human" ? failure2.humanMessage : failure2.message;
-      output2.emit({
-        type: "error",
-        code: failure2.code ?? "TDA_COMMAND_FAILED",
-        message,
-        state: "failed",
-        terminal: true
-      });
-      output2.finish({ status: "error", message });
+      const code = failure2.code ?? (service?.hasFailureScope ? chatFailureCode(error62) : FALLBACK_FAILURE_CODE);
+      const details = await service?.describeFailure(error62, code);
+      const message = mode === "human" ? [
+        failure2.humanMessage,
+        ...details ? formatChatFailureDetails(details) : []
+      ].join("\n") : failure2.message;
+      const record2 = toFailureRecord({ code, message }, details);
+      output2.emit({ type: "error", ...record2, state: "failed", terminal: true });
+      output2.finish(record2);
     },
     onFinally: () => {
       stopEarlySpinner();
@@ -36972,7 +37465,12 @@ async function runAuthorizationCommand(command, operation) {
     onSuccess: (result, { mode, output: output2 }) => {
       if (mode === "json") return output2.finish(result);
       stopEarlySpinner();
-      writeResult(mode, result, { human: formatConnectionChange });
+      writeResult(mode, result, {
+        human: formatConnectionChange,
+        ndjson: (completed) => [
+          { type: "connection_completed", ...completed, terminal: true }
+        ]
+      });
     },
     onInterrupted: ({ output: output2 }) => {
       output2.emit({
@@ -36986,14 +37484,9 @@ async function runAuthorizationCommand(command, operation) {
     onError: (error62, { mode, output: output2 }) => {
       const failure2 = renderFailure(error62, { mode, source });
       const message = mode === "human" ? failure2.humanMessage : failure2.message;
-      output2.emit({
-        type: "error",
-        status: "error",
-        message,
-        ...failure2.code ? { code: failure2.code } : {},
-        terminal: true
-      });
-      output2.finish({ status: "error", message });
+      const record2 = toFailureRecord({ code: failure2.code, message });
+      output2.emit({ type: "error", ...record2, terminal: true });
+      output2.finish(record2);
     },
     onFinally: () => stopEarlySpinner()
   });
@@ -37366,7 +37859,7 @@ function registerConnectorCommand(program) {
 }
 
 // src/lib/manifest-input.ts
-import { CliError as CliError4, getErrorMessage as getErrorMessage7 } from "@doist/cli-core";
+import { CliError as CliError8, getErrorMessage as getErrorMessage8 } from "@doist/cli-core";
 import { Option as Option6 } from "commander";
 import { readFile as readFile2 } from "node:fs/promises";
 import { text } from "node:stream/consumers";
@@ -37380,9 +37873,9 @@ async function readManifestInput(options, input2 = process.stdin) {
   try {
     return JSON.parse(source.content);
   } catch (error62) {
-    throw new CliError4(
+    throw new CliError8(
       "MANIFEST_UNREADABLE",
-      `${source.label} is not valid JSON: ${getErrorMessage7(error62)}`
+      `${source.label} is not valid JSON: ${getErrorMessage8(error62)}`
     );
   }
 }
@@ -37391,9 +37884,9 @@ async function readSource(options, input2) {
     try {
       return { label: options.file, content: await readFile2(options.file, "utf8") };
     } catch (error62) {
-      throw new CliError4(
+      throw new CliError8(
         "MANIFEST_UNREADABLE",
-        `Could not read ${options.file}: ${getErrorMessage7(error62)}`
+        `Could not read ${options.file}: ${getErrorMessage8(error62)}`
       );
     }
   }
@@ -37401,17 +37894,17 @@ async function readSource(options, input2) {
     try {
       return { label: "Standard input", content: await text(input2) };
     } catch (error62) {
-      throw new CliError4(
+      throw new CliError8(
         "MANIFEST_UNREADABLE",
-        `Could not read standard input: ${getErrorMessage7(error62)}`
+        `Could not read standard input: ${getErrorMessage8(error62)}`
       );
     }
   }
-  throw new CliError4("MANIFEST_UNREADABLE", "Provide the manifest with --file <path> or --stdin.");
+  throw new CliError8("MANIFEST_UNREADABLE", "Provide the manifest with --file <path> or --stdin.");
 }
 
 // src/commands/draft/draft-service.ts
-import { CliError as CliError5, getErrorMessage as getErrorMessage8 } from "@doist/cli-core";
+import { CliError as CliError9, getErrorMessage as getErrorMessage9 } from "@doist/cli-core";
 import { readFile as readFile3 } from "node:fs/promises";
 function createDraft2(draftApi, input2) {
   return withRecoveryHints(draftApi, createDraft(draftApi, input2));
@@ -37444,13 +37937,13 @@ async function withRecoveryHints(draftApi, operation) {
     const draftId = error62.draftId ?? "<draft-id>";
     switch (error62.code) {
       case "manifest_invalid":
-        throw new CliError5("MANIFEST_INVALID", error62.message);
+        throw new CliError9("MANIFEST_INVALID", error62.message);
       case "draft_conflict":
-        throw new CliError5("DRAFT_CONFLICT", error62.message, {
+        throw new CliError9("DRAFT_CONFLICT", error62.message, {
           hints: draftHints(scope, draftId)
         });
       case "draft_manifest_rejected":
-        throw new CliError5("DRAFT_MANIFEST_REJECTED", error62.message, {
+        throw new CliError9("DRAFT_MANIFEST_REJECTED", error62.message, {
           hints: draftHints(scope, draftId)
         });
       case "draft_not_ready":
@@ -37468,14 +37961,12 @@ function draftHints(scope, draftId) {
     `Or discard it first: tda draft delete ${draftId} --yes ${scopeFlag(scope)}`
   ];
 }
-function scopeFlag(scope) {
-  return scope === null ? "--personal" : `--workspace ${scope}`;
-}
 async function startDraftTest2(draftApi, {
   draftId,
   request: request2,
   wait: waitFor,
-  signal
+  signal,
+  onProgress
 }) {
   let started;
   try {
@@ -37497,9 +37988,21 @@ async function startDraftTest2(draftApi, {
   }
   let finished;
   try {
-    finished = await waitForDraftTest(draftApi, started, { ...waitFor, signal });
+    finished = await waitForDraftTest(draftApi, started, {
+      ...waitFor,
+      signal,
+      ...onProgress ? { onPoll: reportRunProgress(onProgress) } : {}
+    });
   } catch (error62) {
-    throw toDraftTestWaitError(error62, identity, signal);
+    throw toRunWaitError(error62, {
+      run: `test run ${identity.testRunId} of draft ${identity.draftId}`,
+      command: identity.command,
+      codes: {
+        interrupted: "DRAFT_TEST_WAIT_INTERRUPTED",
+        failed: "DRAFT_TEST_WAIT_FAILED"
+      },
+      signal
+    });
   }
   return {
     action: "test_finished",
@@ -37511,25 +38014,9 @@ async function startDraftTest2(draftApi, {
     result: finished.result
   };
 }
-function toDraftTestWaitError(error62, identity, signal) {
-  const run = `test run ${identity.testRunId} of draft ${identity.draftId}`;
-  const hints = [`See how it ends: ${identity.command}`];
-  if (signal.aborted) {
-    return new CliError5(
-      "DRAFT_TEST_WAIT_INTERRUPTED",
-      `Stopped waiting for ${run}. It keeps running.`,
-      { hints }
-    );
-  }
-  return new CliError5(
-    "DRAFT_TEST_WAIT_FAILED",
-    `Checking on ${run} failed: ${getErrorMessage8(error62).replace(/\.?$/, ".")} It keeps running.`,
-    { hints }
-  );
-}
 function draftNotReadyError(message, draftId, scope) {
   const flag = scopeFlag(scope);
-  return new CliError5("DRAFT_NOT_READY", message, {
+  return new CliError9("DRAFT_NOT_READY", message, {
     hints: [
       `See the issues: tda draft view ${draftId} ${flag}`,
       `Bind connections: tda draft connect ${draftId} --auto ${flag}`
@@ -37543,13 +38030,13 @@ function toDraftTestCliError(refusal, draftId, scope) {
       return draftNotReadyError(refusal.message, draftId, scope);
     case "draft_test_payload_required":
     case "draft_test_payload_filtered":
-      return new CliError5(refusal.code.toUpperCase(), refusal.message, {
+      return new CliError9(refusal.code.toUpperCase(), refusal.message, {
         hints: [
           `Test with a real event: tda draft test ${draftId} --trigger <event> --payload-file <path> ${flag}`
         ]
       });
     default:
-      return new CliError5(refusal.code.toUpperCase(), refusal.message);
+      return new CliError9(refusal.code.toUpperCase(), refusal.message);
   }
 }
 async function readTestPayloadFile(path) {
@@ -37557,17 +38044,17 @@ async function readTestPayloadFile(path) {
   try {
     content = await readFile3(path, "utf8");
   } catch (error62) {
-    throw new CliError5(
+    throw new CliError9(
       "PAYLOAD_UNREADABLE",
-      `Could not read ${path}: ${getErrorMessage8(error62)}`
+      `Could not read ${path}: ${getErrorMessage9(error62)}`
     );
   }
   try {
     return JSON.parse(content);
   } catch (error62) {
-    throw new CliError5(
+    throw new CliError9(
       "PAYLOAD_UNREADABLE",
-      `${path} is not valid JSON: ${getErrorMessage8(error62)}`
+      `${path} is not valid JSON: ${getErrorMessage9(error62)}`
     );
   }
 }
@@ -37754,7 +38241,7 @@ function formatDraftTest(result) {
 }
 
 // src/commands/draft/validate-command.ts
-import { CliError as CliError6 } from "@doist/cli-core";
+import { CliError as CliError10 } from "@doist/cli-core";
 
 // src/lib/local-command.ts
 async function runLocalCommand(command, operation, presentation, execution = {}) {
@@ -37786,7 +38273,7 @@ function registerDraftValidateCommand(draft) {
 function validateManifestInput(manifest) {
   const validation = validateManifest(manifest);
   if (!validation.isValid) {
-    throw new CliError6(
+    throw new CliError10(
       "MANIFEST_INVALID",
       `Manifest is invalid: ${validation.errors.join("; ")}`
     );
@@ -37806,8 +38293,6 @@ 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, test and inspect automation drafts");
   registerDraftValidateCommand(draft);
@@ -37934,9 +38419,9 @@ function registerDraftCommand(program) {
     );
   });
   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})`
+    addWaitOptions(
+      draft.command("test").description("Start a test run of a draft, with mocked connector calls").argument("<draft-id>", "Draft ID"),
+      "Wait for the run to end and exit 1 unless it passed"
     ).option(
       "--trigger <index|event>",
       "The trigger to test: its position in the manifest's triggers, or a webhook event"
@@ -37947,11 +38432,8 @@ function registerDraftCommand(program) {
   ).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);
+      async ({ api, signal, progress }) => {
+        const wait2 = resolveWait(options);
         const draftApi = bindDraftApi(api, await resolveWorkspaceScope(options), { signal });
         return startDraftTest2(draftApi, {
           draftId,
@@ -37959,14 +38441,15 @@ function registerDraftCommand(program) {
             ...options.trigger !== void 0 ? { trigger: toDraftTestTriggerSelector(options.trigger) } : {},
             ...options.payloadFile !== void 0 ? { payload: await readTestPayloadFile(options.payloadFile) } : {}
           },
-          wait: options.wait === true ? { timeoutMs } : null,
-          signal
+          wait: wait2,
+          signal,
+          onProgress: (state) => progress({ type: "test_progress", draftId, ...state })
         });
       },
-      { human: formatDraftTest },
+      { human: formatDraftTest, ndjson: toTerminalRecords },
       {
         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,
+        minimumTokenLifetimeMs: waitTokenLifetimeMs(options),
         exitCode: (result) => result.action === "test_finished" && result.outcome !== "passed" ? 1 : void 0
       }
     );
@@ -38026,20 +38509,6 @@ 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";
@@ -38135,11 +38604,11 @@ function registerRunCommand(program) {
 }
 
 // src/commands/skill/shared.ts
-import { CliError as CliError7 } from "@doist/cli-core";
+import { CliError as CliError11 } from "@doist/cli-core";
 function requireInstaller(agent) {
   const installer = getInstaller(agent);
   if (!installer) {
-    throw new CliError7("UNKNOWN_AGENT", `Unknown agent: ${agent}.`, {
+    throw new CliError11("UNKNOWN_AGENT", `Unknown agent: ${agent}.`, {
       hints: [`Available agents: ${AGENT_NAMES.join(", ")}.`]
     });
   }
@@ -38217,7 +38686,7 @@ async function uninstallSkill(agent, options, command) {
 }
 
 // src/commands/skill/update.ts
-import { CliError as CliError8 } from "@doist/cli-core";
+import { CliError as CliError12 } from "@doist/cli-core";
 async function updateSkill(agent, options, command) {
   await runLocalCommand(
     command,
@@ -38243,7 +38712,7 @@ async function updateAllSkills(options, command) {
     async () => {
       const result = await updateAllInstalledSkills(options.local === true);
       if (result.errors.length > 0) {
-        throw new CliError8(
+        throw new CliError12(
           "UPDATE_FAILED",
           `Could not update ${result.errors.length} skill file(s).`,
           { hints: result.errors.map((error62) => `${error62.agent}: ${error62.message}`) }
@@ -38303,7 +38772,7 @@ function registerUpdateCommand(program) {
 }
 
 // src/commands/workspace/index.ts
-import { CliError as CliError9 } from "@doist/cli-core";
+import { CliError as CliError13 } from "@doist/cli-core";
 
 // src/commands/workspace/format.ts
 function formatWorkspaceList(workspaces) {
@@ -38346,7 +38815,7 @@ function registerWorkspaceCommand(program) {
           if (!(error62 instanceof AutomationsRequestError) || error62.httpStatusCode !== 404) {
             throw error62;
           }
-          throw new CliError9(
+          throw new CliError13(
             "WORKSPACE_ACCESS_UNAVAILABLE",
             "Workspace access is not available for this account or environment.",
             {