@wave-ai-os/wave-cli 0.1.78 → 0.1.80

package/dist/index.js

@@ -327,6 +327,9 @@ function buildAtlasActionLedgerRequest(params) {
 }
 
 // src/client/graphqlClient.ts
+var MAX_QUERY_ATTEMPTS = 3;
+var MAX_RETRY_DELAY_MS = 2e3;
+var TRANSIENT_QUERY_STATUSES = /* @__PURE__ */ new Set([429, 502, 503, 504]);
 function buildEnvelope(params) {
   return {
     ok: params.ok,
@@ -357,6 +360,47 @@ function debugLog(config, message) {
   process.stderr.write(`[wave:debug] ${message}
 `);
 }
+function retryAfterDelayMs(value, nowMs = Date.now()) {
+  if (value === null) {
+    return null;
+  }
+  const trimmed = value.trim();
+  if (/^\d+$/.test(trimmed)) {
+    return Math.min(Number(trimmed) * 1e3, MAX_RETRY_DELAY_MS);
+  }
+  const retryAtMs = Date.parse(trimmed);
+  if (Number.isNaN(retryAtMs)) {
+    return null;
+  }
+  return Math.min(Math.max(retryAtMs - nowMs, 0), MAX_RETRY_DELAY_MS);
+}
+function retryDelayMs(attempt, retryAfter) {
+  const serverDelay = retryAfterDelayMs(retryAfter);
+  if (serverDelay !== null) {
+    return serverDelay;
+  }
+  const exponentialCeiling = Math.min(100 * 2 ** (attempt - 1), MAX_RETRY_DELAY_MS);
+  return Math.floor(Math.random() * exponentialCeiling);
+}
+function waitForRetry(delayMs, signal) {
+  if (signal.aborted) {
+    return Promise.reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+  }
+  if (delayMs <= 0) {
+    return Promise.resolve();
+  }
+  return new Promise((resolve, reject) => {
+    const timeoutId = setTimeout(() => {
+      signal.removeEventListener("abort", handleAbort);
+      resolve();
+    }, delayMs);
+    const handleAbort = () => {
+      clearTimeout(timeoutId);
+      reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+    };
+    signal.addEventListener("abort", handleAbort, { once: true });
+  });
+}
 function graphqlOperationName(command) {
   return command.split(/[^a-zA-Z0-9]/).filter(Boolean).map((part) => part[0].toUpperCase() + part.slice(1)).join("");
 }
@@ -674,10 +718,41 @@ async function requestGraphqlHttp(params) {
   return {
     status: response.status,
     requestId: responseRequestId,
+    retryAfter: response.headers.get("retry-after"),
     body,
     graph
   };
 }
+async function requestGraphqlHttpWithRetry(params) {
+  const maxAttempts = params.input.operationType === "query" ? MAX_QUERY_ATTEMPTS : 1;
+  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    try {
+      const response = await requestGraphqlHttp(params);
+      const shouldRetry = attempt < maxAttempts && TRANSIENT_QUERY_STATUSES.has(response.status);
+      if (!shouldRetry) {
+        return response;
+      }
+      const delayMs = retryDelayMs(attempt, response.retryAfter);
+      debugLog(
+        params.input.config,
+        `graphql retry command=${params.input.command} attempt=${attempt + 1}/${maxAttempts} status=${response.status} delayMs=${delayMs}`
+      );
+      await waitForRetry(delayMs, params.controller.signal);
+    } catch (error) {
+      if (attempt >= maxAttempts || params.controller.signal.aborted) {
+        throw error;
+      }
+      const delayMs = retryDelayMs(attempt, null);
+      const message = error instanceof Error ? error.message : "Network error.";
+      debugLog(
+        params.input.config,
+        `graphql retry command=${params.input.command} attempt=${attempt + 1}/${maxAttempts} error=${message} delayMs=${delayMs}`
+      );
+      await waitForRetry(delayMs, params.controller.signal);
+    }
+  }
+  throw new Error("GraphQL query retry attempts exhausted.");
+}
 async function reportAtlasLedgerForResult(input, url, result) {
   const ledgerInput = buildAtlasActionLedgerRequest({
     config: input.config,
@@ -858,7 +933,7 @@ async function graphqlRequest(input) {
         }
       }
     }
-    const http = await requestGraphqlHttp({
+    const http = await requestGraphqlHttpWithRetry({
       input,
       url,
       requestId,
@@ -3036,18 +3111,24 @@ var dtoHelpCatalog = {
     create: [
       ["rank", "number"],
       ["organization_id", "string"],
-      ["list_id", "string"],
-      ["summary", "string"],
+      ["list_id*", "string"],
+      ["summary*", "string"],
       ["member_id", "string"],
-      ["status", "ListItemStatus"],
+      ["status", "enum(open|completed)"],
       ["due_date", "string"],
-      ["priority", "Priority"],
+      ["priority", "enum(no_priority|urgent|high|medium|low)"],
       ["description", "string"],
       ["notes", "string | null"],
       ["label_ids", "number[]"],
       ["estimate_ids", "number[]"],
       ["resources_attributes", "ResourceDTO[]"],
-      ["subitems_attributes", "SubitemAttributes[]"]
+      ["subitems_attributes", "object[]"],
+      ["subitems_attributes[].name", "string"],
+      ["subitems_attributes[].member_id", "string"],
+      ["subitems_attributes[].status", "enum(active|completed)"],
+      ["subitems_attributes[].priority", "enum(no_priority|urgent|high|medium|low)"],
+      ["subitems_attributes[].description", "string"],
+      ["subitems_attributes[].notes", "string | null"]
     ],
     update: [
       ["rank", "number"],
@@ -3055,18 +3136,50 @@ var dtoHelpCatalog = {
       ["list_id", "string"],
       ["summary", "string"],
       ["member_id", "string"],
-      ["status", "ListItemStatus"],
+      ["status", "enum(open|completed)"],
       ["due_date", "string"],
-      ["priority", "Priority"],
+      ["priority", "enum(no_priority|urgent|high|medium|low)"],
       ["description", "string"],
       ["notes", "string | null"],
       ["label_ids", "number[]"],
       ["estimate_ids", "number[]"],
       ["resources_attributes", "ResourceDTO[]"],
-      ["subitems_attributes", "SubitemAttributes[]"],
+      ["subitems_attributes", "object[]"],
+      ["subitems_attributes[].name", "string"],
+      ["subitems_attributes[].member_id", "string"],
+      ["subitems_attributes[].status", "enum(active|completed)"],
+      ["subitems_attributes[].priority", "enum(no_priority|urgent|high|medium|low)"],
+      ["subitems_attributes[].description", "string"],
+      ["subitems_attributes[].notes", "string | null"],
       ["archived_at", "string | null"]
     ]
   },
+  subitem: {
+    source: "wave-api-rb/config/initializers/constants/subitem.rb + wave-api-rb/app/models/subitem.rb",
+    create: [
+      ["list_item_id*", "string"],
+      ["name*", "string"],
+      ["member_id", "string"],
+      ["status", "enum(active|completed)"],
+      ["priority", "enum(no_priority|urgent|high|medium|low)"],
+      ["description", "string"],
+      ["notes", "string | null"],
+      ["rank", "number"],
+      ["due_date", "string"],
+      ["estimate_ids", "number[]"]
+    ],
+    update: [
+      ["name", "string"],
+      ["member_id", "string"],
+      ["status", "enum(active|completed)"],
+      ["priority", "enum(no_priority|urgent|high|medium|low)"],
+      ["description", "string"],
+      ["notes", "string | null"],
+      ["rank", "number"],
+      ["due_date", "string"],
+      ["estimate_ids", "number[]"]
+    ]
+  },
   issue_group: {
     source: "wave-ui/src/types/issueGroup.ts + wave-api-rb/config/initializers/constants/issue_group.rb + wave-api-rb/app/models/issue_group.rb",
     create: [
@@ -3441,6 +3554,24 @@ function toRows(fields, mode) {
     return `${field} | required:${requiredForMode} | type:${type} | ${humanize(field)}`;
   });
 }
+function exampleValue(type) {
+  if (type === "number") return 1;
+  if (type === "boolean") return true;
+  if (type.endsWith("[]")) return [];
+  const enumValues = /^enum\(([^)]+)\)$/u.exec(type)?.[1]?.split("|");
+  return enumValues?.[0] ?? "value";
+}
+function examplePayload(rootKey, fields, mode) {
+  const requiredFields = mode === "create" ? fields.filter(([field]) => field.endsWith("*")) : [];
+  const exampleFields = requiredFields.length > 0 ? requiredFields : fields.slice(0, 1);
+  const entity = Object.fromEntries(
+    exampleFields.map(([rawField, type]) => [
+      rawField.replace(/\*$/u, ""),
+      exampleValue(type)
+    ])
+  );
+  return JSON.stringify({ [rootKey]: entity });
+}
 function buildDataJsonHelp(rootKey, mode) {
   const config = dtoHelpCatalog[rootKey];
   if (!config) return null;
@@ -3453,10 +3584,205 @@ function buildDataJsonHelp(rootKey, mode) {
     `note: fields containing "preference" are intentionally omitted.`,
     "field | required | type | description",
     ...toRows(fields, mode),
-    `example: {"${rootKey}":{"${fields[0][0].replace(/\*$/, "")}":"value"}}`
+    `example: ${examplePayload(rootKey, fields, mode)}`
   ].join("\n");
 }
 
+// src/entityPayloadContracts.ts
+var PRIORITIES = ["no_priority", "urgent", "high", "medium", "low"];
+var SUBITEM_STATUSES = ["active", "completed"];
+var LIST_ITEM_STATUSES = ["open", "completed"];
+var subitemFields = {
+  list_item_id: { type: "string" },
+  name: { type: "string" },
+  status: { type: "string", enum: SUBITEM_STATUSES },
+  priority: { type: "string", enum: PRIORITIES }
+};
+var listItemFields = {
+  list_id: { type: "string" },
+  summary: { type: "string" },
+  status: { type: "string", enum: LIST_ITEM_STATUSES },
+  priority: { type: "string", enum: PRIORITIES },
+  subitems_attributes: {
+    type: "array",
+    items: {
+      type: "object",
+      fields: subitemFields,
+      required: ["name"]
+    }
+  }
+};
+var listItemCreateContract = {
+  rootKey: "list_item",
+  fields: listItemFields,
+  required: ["list_id", "summary"]
+};
+var listItemUpdateContract = {
+  rootKey: "list_item",
+  fields: listItemFields
+};
+var subitemCreateContract = {
+  rootKey: "subitem",
+  fields: subitemFields,
+  required: ["list_item_id", "name"]
+};
+var subitemUpdateContract = {
+  rootKey: "subitem",
+  fields: subitemFields
+};
+var CONTRACTS = {
+  "list-items.create": listItemCreateContract,
+  "list-items.update": listItemUpdateContract,
+  "subitems.create": subitemCreateContract,
+  "subitems.update": subitemUpdateContract
+};
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function parsePayload(value) {
+  if (typeof value !== "string") return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return /* @__PURE__ */ Symbol.for("invalid-json");
+  }
+}
+function typeMatches(value, type) {
+  if (!type) return true;
+  if (type === "array") return Array.isArray(value);
+  if (type === "object") return isPlainObject(value);
+  return typeof value === type;
+}
+function validateField(contract, value, path) {
+  if (!typeMatches(value, contract.type)) {
+    return [`${path.join(".")} must be ${contract.type}.`];
+  }
+  if (contract.enum && !contract.enum.includes(value)) {
+    return [`${path.join(".")} must be one of ${contract.enum.join(", ")}.`];
+  }
+  if (contract.type === "object" && contract.fields && isPlainObject(value)) {
+    const missing = (contract.required ?? []).filter(
+      (field) => value[field] === void 0 || value[field] === null || value[field] === ""
+    );
+    return [
+      ...missing.map((field) => `${[...path, field].join(".")} is required.`),
+      ...validateFields(contract.fields, value, path)
+    ];
+  }
+  if (contract.type === "array" && contract.items && Array.isArray(value)) {
+    return value.flatMap(
+      (item, index) => validateField(contract.items, item, [...path, index])
+    );
+  }
+  return [];
+}
+function validateFields(fields, value, path) {
+  return Object.entries(fields).flatMap(([field, contract]) => {
+    const fieldValue = value[field];
+    return fieldValue === void 0 ? [] : validateField(contract, fieldValue, [...path, field]);
+  });
+}
+function contractEntity(contract, payload) {
+  if (!isPlainObject(payload)) return null;
+  if (!(contract.rootKey in payload)) return payload;
+  const rooted = payload[contract.rootKey];
+  return isPlainObject(rooted) ? rooted : null;
+}
+function validateOperationDataJson(operationId2, value) {
+  const contract = CONTRACTS[operationId2];
+  if (!contract) return [];
+  const payload = parsePayload(value);
+  if (payload === /* @__PURE__ */ Symbol.for("invalid-json")) {
+    return ["Invalid input value for dataJson: must be valid JSON."];
+  }
+  const entity = contractEntity(contract, payload);
+  if (!entity) {
+    return [
+      `Invalid input value for dataJson: ${contract.rootKey} payload must be a JSON object.`
+    ];
+  }
+  const missing = (contract.required ?? []).filter(
+    (field) => entity[field] === void 0 || entity[field] === null || entity[field] === ""
+  );
+  return [
+    ...missing.map((field) => `${contract.rootKey}.${field} is required.`),
+    ...validateFields(contract.fields, entity, [contract.rootKey])
+  ].map(
+    (error) => `Invalid input value for dataJson: ${error}`
+  );
+}
+function assertOperationPayload(operationId2, body) {
+  const errors = validateOperationDataJson(operationId2, body);
+  if (errors.length === 0) return;
+  throw new CliError({
+    message: errors.join(" "),
+    kind: "invalid_args",
+    status: 400,
+    exitCode: EXIT_CODES.invalidArgs
+  });
+}
+function fieldSchema(contract) {
+  const type = contract.type ?? "object";
+  return {
+    type,
+    ...contract.enum ? { enum: [...contract.enum] } : {},
+    ...contract.fields ? {
+      properties: Object.fromEntries(
+        Object.entries(contract.fields).map(([field, nested]) => [
+          field,
+          fieldSchema(nested)
+        ])
+      ),
+      ...contract.required ? { required: [...contract.required] } : {},
+      additionalProperties: true
+    } : {},
+    ...contract.items ? { items: fieldSchema(contract.items) } : {}
+  };
+}
+function entitySchema(contract) {
+  return {
+    type: "object",
+    properties: Object.fromEntries(
+      Object.entries(contract.fields).map(([field, nested]) => [
+        field,
+        fieldSchema(nested)
+      ])
+    ),
+    ...contract.required ? { required: [...contract.required] } : {},
+    additionalProperties: true
+  };
+}
+function exampleDataJsonForOperation(operationId2) {
+  const contract = CONTRACTS[operationId2];
+  if (!contract) return null;
+  const entity = Object.fromEntries(
+    (contract.required ?? []).map((field) => [field, "example"])
+  );
+  return { [contract.rootKey]: entity };
+}
+function dataJsonSchemaPropertyForOperation(operationId2, description) {
+  const contract = CONTRACTS[operationId2];
+  if (!contract) return null;
+  const entity = entitySchema(contract);
+  return {
+    type: ["object", "string"],
+    ...description ? { description } : {},
+    anyOf: [
+      {
+        type: "string",
+        description: "A JSON-serialized payload matching one of the object forms."
+      },
+      entity,
+      {
+        type: "object",
+        properties: { [contract.rootKey]: entity },
+        required: [contract.rootKey],
+        additionalProperties: false
+      }
+    ]
+  };
+}
+
 // src/commands/entityCrud.ts
 var idSchema2 = z4.string().min(1);
 function toSingularResourceName(resourcePath) {
@@ -3630,6 +3956,7 @@ function registerEntityCrudCommands(program, config) {
     if (config.normalizeCreateBody) {
       body = config.normalizeCreateBody(body);
     }
+    assertOperationPayload(`${config.command}.create`, body);
     assertRequiredCreateFields(body, config.rootKey, config.requiredCreateFields);
     const defaultCommand = `${config.command}.create`;
     const defaultField = `create_${toSingularResourceName(config.resourcePath)}`;
@@ -3662,6 +3989,7 @@ function registerEntityCrudCommands(program, config) {
     if (config.normalizeUpdateBody) {
       body = config.normalizeUpdateBody(body);
     }
+    assertOperationPayload(`${config.command}.update`, body);
     const singular = toSingularResourceName(config.resourcePath);
     await runGraphqlMutationCommand({
       command: `${config.command}.update`,
@@ -6194,13 +6522,17 @@ function registerChildCommands(program, config) {
     ...config.searchRequiredOptions ? { requiredOptions: config.searchRequiredOptions } : {}
   };
   registerGraphqlSearchCommand(command, searchConfig);
-  command.command("create").requiredOption("--data-json <dataJson>").action(async (opts, cmd) => {
+  command.command("create").requiredOption(
+    "--data-json <dataJson>",
+    buildDataJsonHelp(config.rootKey, "create") ?? void 0
+  ).action(async (opts, cmd) => {
     const context = await resolveCommandContext(cmd.optsWithGlobals());
     const organizationId = resolveOrganizationId(context.organizationId);
     let body = normalizeBody2(String(opts.dataJson), config.rootKey);
     if (config.normalizeCreateBody) {
       body = config.normalizeCreateBody(body);
     }
+    assertOperationPayload(`${config.command}.create`, body);
     assertRequiredParent(body, config.rootKey, config.parentFlag.replace(/-/g, "_"));
     await runGraphqlMutationCommand({
       command: `${config.command}.create`,
@@ -6213,11 +6545,15 @@ function registerChildCommands(program, config) {
       }
     });
   });
-  command.command("update").requiredOption("--id <id>").requiredOption("--data-json <dataJson>").action(async (opts, cmd) => {
+  command.command("update").requiredOption("--id <id>").requiredOption(
+    "--data-json <dataJson>",
+    buildDataJsonHelp(config.rootKey, "update") ?? void 0
+  ).action(async (opts, cmd) => {
     const context = await resolveCommandContext(cmd.optsWithGlobals());
     const organizationId = resolveOrganizationId(context.organizationId);
     const id = idSchema12.parse(opts.id);
     const body = normalizeBody2(String(opts.dataJson), config.rootKey);
+    assertOperationPayload(`${config.command}.update`, body);
     await runGraphqlMutationCommand({
       command: `${config.command}.update`,
       operationName: config.updateOperationName,
@@ -14862,6 +15198,29 @@ var AUTOMATION_RUN_SELECTION = `{
     targetId
   }
 }`;
+var AUTOMATION_RUN_STATUS_SELECTION = `{
+  status
+  automationTaskId
+  automationTaskSlug
+  agentId
+  agentSlug
+  agentTriggerId
+  chatId
+  chatSlug
+  chatLane
+  messageId
+  runId
+  executionId
+  executionSlug
+  traceId
+  correlationId
+  outputContentId
+  outputContentSlug
+  terminalReason
+  error
+  queuedAt
+  completedAt
+}`;
 function asRecord7(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
@@ -14992,15 +15351,58 @@ function normalizeAutomationRunPayload(payload) {
   const automationTaskId = asRequiredString(data?.automation_task_id);
   const automationTaskSlug = asRequiredString(data?.automation_task_slug);
   const agentId = asRequiredString(data?.agent_id);
-  const agentSlug = asRequiredString(data?.agent_slug);
-  const agentTriggerId = asRequiredString(data?.agent_trigger_id);
-  const executionId = asRequiredString(data?.execution_id);
-  const executionSlug = asRequiredString(data?.execution_slug);
   const executionStatus = asRequiredString(data?.execution_status);
-  const traceId = asRequiredString(data?.trace_id);
-  if (!data || !automationTaskId || !automationTaskSlug || !agentId || !agentSlug || !agentTriggerId || !executionId || !executionSlug || !executionStatus || !traceId) {
+  if (!data || !automationTaskId || !automationTaskSlug || !agentId || !executionStatus) {
     throw new CliError({
-      message: "Automation run response did not include automation, execution, and trace evidence.",
+      message: "Automation run response did not include automation identity and status.",
+      kind: "malformed_response",
+      status: 502,
+      exitCode: EXIT_CODES.networkOrUpstream
+    });
+  }
+  if (executionStatus === "queued") {
+    const chatId = asRequiredString(data.chat_id);
+    const chatSlug = asRequiredString(data.chat_slug);
+    const chatLane = asRequiredString(data.chat_lane);
+    const messageId = asRequiredString(data.message_id);
+    const runId = asRequiredString(data.run_id);
+    const memberId = asRequiredString(data.member_id);
+    if (!chatId || !chatSlug || !chatLane || !messageId || !runId || !memberId) {
+      throw new CliError({
+        message: "Queued Automation response did not include chat, message, run, and member identity.",
+        kind: "malformed_response",
+        status: 502,
+        exitCode: EXIT_CODES.networkOrUpstream
+      });
+    }
+    return {
+      ok: mutation.ok,
+      status: mutation.status,
+      errorCode: mutation.errorCode ?? null,
+      errors: mutation.errors ?? null,
+      run: {
+        executed: data.executed === true,
+        status: executionStatus,
+        automation: { id: automationTaskId, slug: automationTaskSlug },
+        agent: { id: agentId },
+        trigger: { id: asRequiredString(data.agent_trigger_id) },
+        queue: {
+          chat: { id: chatId, slug: chatSlug, lane: chatLane },
+          message_id: messageId,
+          run_id: runId,
+          member_id: memberId
+        },
+        readback_command: `wave automations run-status --id ${automationTaskSlug} --message-id ${messageId} --run-id ${runId}`
+      }
+    };
+  }
+  const agentSlug = asRequiredString(data.agent_slug);
+  const executionId = asRequiredString(data.execution_id);
+  const executionSlug = asRequiredString(data.execution_slug);
+  const traceId = asRequiredString(data.trace_id);
+  if (!agentSlug || !executionId || !executionSlug || !traceId) {
+    throw new CliError({
+      message: "Terminal Automation response did not include execution and trace evidence.",
       kind: "malformed_response",
       status: 502,
       exitCode: EXIT_CODES.networkOrUpstream
@@ -15023,7 +15425,7 @@ function normalizeAutomationRunPayload(payload) {
         slug: agentSlug
       },
       trigger: {
-        id: agentTriggerId,
+        id: asRequiredString(data.agent_trigger_id),
         type: asRequiredString(data.trigger_type)
       },
       execution: {
@@ -15320,7 +15722,7 @@ function registerAtlasAuthoringCommands(program) {
       isShow: true
     });
   });
-  automations.command("run").description("Run one scheduled Automation by id or slug and return execution trace evidence").requiredOption("--id <idOrSlug>", "Automation id or slug").action(async (opts, cmd) => {
+  automations.command("run").description("Queue one Automation by id or slug and return exact status readback identifiers").requiredOption("--id <idOrSlug>", "Automation id or slug").action(async (opts, cmd) => {
     const automationId = idSchema14.parse(opts.id);
     const context = await resolveCommandContext(cmd.optsWithGlobals());
     const organizationId = resolveOrganizationId(context.organizationId);
@@ -15334,6 +15736,33 @@ function registerAtlasAuthoringCommands(program) {
       transformMutationPayload: normalizeAutomationRunPayload
     });
   });
+  automations.command("run-status").description("Read one queued or terminal Automation execution by its run identity").requiredOption("--id <idOrSlug>", "Automation id or slug returned by automations run").requiredOption("--message-id <messageId>", "Message id returned by automations run").requiredOption("--run-id <runId>", "Run id returned by automations run").action(async (opts, cmd) => {
+    const automationId = idSchema14.parse(opts.id);
+    const messageId = idSchema14.parse(opts.messageId);
+    const runId = idSchema14.parse(opts.runId);
+    const context = await resolveCommandContext(cmd.optsWithGlobals());
+    const organizationId = resolveOrganizationId(context.organizationId);
+    await runGraphqlQueryCommand({
+      command: "automations.run-status",
+      operationName: "AutomationsRunStatus",
+      runtimeOptions: context.runtimeOptions,
+      field: "automation_run_status",
+      variables: {
+        organization_id: organizationId,
+        automation_id: automationId,
+        message_id: messageId,
+        run_id: runId
+      },
+      variableTypes: {
+        organization_id: "ID!",
+        automation_id: "ID!",
+        message_id: "ID!",
+        run_id: "ID!"
+      },
+      selectionSet: AUTOMATION_RUN_STATUS_SELECTION,
+      isShow: true
+    });
+  });
   automations.command("run-show").description("Read one Automation run artifact by Agent id and execution slug").requiredOption("--agent-id <agentIdOrSlug>", "Agent id or slug").requiredOption("--execution-slug <executionSlug>", "Execution slug returned by automations run").action(async (opts, cmd) => {
     const agentId = idSchema14.parse(opts.agentId);
     const executionSlug = idSchema14.parse(opts.executionSlug);
@@ -15496,7 +15925,7 @@ import { join as join3 } from "path";
 import { createHash } from "crypto";
 
 // src/version.ts
-var CLI_VERSION = "0.1.77";
+var CLI_VERSION = "0.1.80";
 
 // src/operationMetadata.ts
 var DISCOVERY_OPERATION_IDS = [
@@ -15619,6 +16048,7 @@ var READ_OPERATION_IDS = [
   "agents.show",
   "auth.status",
   "automations.run-show",
+  "automations.run-status",
   "automations.show",
   "broadcast.community",
   "broadcast.list",
@@ -16033,7 +16463,7 @@ function operationId(path) {
 function inputKeyForArgument(argument) {
   return argument.name().replace(/<|>|\[|\]|\.\.\./g, "");
 }
-function inputSchemaFor(command) {
+function inputSchemaFor(command, id) {
   const properties = {};
   const required = [];
   for (const argument of command.registeredArguments) {
@@ -16047,7 +16477,8 @@ function inputSchemaFor(command) {
   for (const option of command.options) {
     const key = option.attributeName();
     if (MACHINE_PRESENTATION_OPTIONS.has(key)) continue;
-    properties[key] = {
+    const payloadSchema = key === "dataJson" ? dataJsonSchemaPropertyForOperation(id, option.description) : null;
+    properties[key] = payloadSchema ?? {
       type: option.required ? "string" : option.optional ? ["boolean", "string"] : "boolean",
       ...option.description ? { description: option.description } : {}
     };
@@ -16060,12 +16491,17 @@ function inputSchemaFor(command) {
     required: required.sort()
   };
 }
-function exampleFor(inputSchema) {
+function exampleFor(inputSchema, id) {
   const input = {};
   for (const key of inputSchema.required) {
+    const payloadExample = key === "dataJson" ? exampleDataJsonForOperation(id) : null;
+    if (payloadExample) {
+      input[key] = payloadExample;
+      continue;
+    }
     const propertyType = inputSchema.properties[key]?.type;
     const types = Array.isArray(propertyType) ? propertyType : [propertyType];
-    input[key] = types.includes("array") ? ["example"] : types.includes("boolean") ? true : "example";
+    input[key] = types.includes("object") ? {} : types.includes("array") ? ["example"] : types.includes("boolean") ? true : "example";
   }
   return [{ name: "minimal valid input", input }];
 }
@@ -16096,7 +16532,8 @@ function listInvocableCommands(program) {
 }
 function entryFor(command, metadata) {
   const path = commandPath(command);
-  const inputSchema = inputSchemaFor(command);
+  const id = operationId(path);
+  const inputSchema = inputSchemaFor(command, id);
   const summary = command.description() || `Run ${path.join(" ")}.`;
   return {
     id: operationId(path),
@@ -16109,7 +16546,7 @@ function entryFor(command, metadata) {
     atlasSafetyClass: metadata.atlasSafetyClass,
     inputSchema,
     outputSchema: outputSchema(),
-    examples: exampleFor(inputSchema),
+    examples: exampleFor(inputSchema, id),
     machine: metadata.machine
   };
 }
@@ -16327,6 +16764,7 @@ var NAMESPACE_DOCS = {
       `wave automations create --summary "Weekly review" --agent-id 123 --ai-task-config '{"cycle":"repeat","repeatSchedule":{"interval":1,"frequency":"week","weekdays":[1,3],"at":"2:30 PM","starting":"2026-07-20T00:00:00.000Z","ending":"never","endingRuns":1,"endingDate":null,"timezone":"America/Phoenix"}}' --idempotency-key automation-create-001`,
       "wave automations show --id ATK-01",
       "wave automations run --id ATK-01",
+      "wave automations run-status --id ATK-01 --message-id 123 --run-id run_123",
       "wave automations run-show --agent-id AGT-01 --execution-slug ART-1234567890",
       'wave automations update --id ATK-01 --expected-update-version 2026-07-17T12:00:00.123456Z --summary "Weekly project review"'
     ],
@@ -16339,11 +16777,12 @@ var NAMESPACE_DOCS = {
         "Only the API-defined ai_task_config field accepts validated JSON.",
         "Optional executor Agent linkage is sent only through the API-defined top-level agentId input.",
         "Update calls only updateTask with an exact opaque updateVersion token; it cannot change status, task type, ownership, or project linkage.",
-        "Run calls only runAutomationNow for an existing scheduled Automation and returns execution/trace evidence.",
+        "Run calls only runAutomationNow and returns the exact queued chat, message, and run identity.",
+        "Run-status reads queued or terminal execution and trace evidence using that exact identity.",
         "Run-show reads the persisted Automation run artifact through agentAutomationRun by Agent id and execution slug.",
         "Show uses the API-owned automation query by id; no slug fallback is implemented."
       ],
-      commands: ["create", "show", "run", "run-show", "update"]
+      commands: ["create", "show", "run", "run-status", "run-show", "update"]
     }
   },
   broadcast: {
@@ -17234,7 +17673,7 @@ function machineEnvelope(params) {
     meta: { requestId: "machine" }
   };
 }
-function isPlainObject(value) {
+function isPlainObject2(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function hasAction2(command) {
@@ -17308,7 +17747,7 @@ async function readMachineInput(location) {
   }
   if (!raw.trim()) throw new Error("Machine input JSON is required.");
   const parsed = JSON.parse(raw);
-  if (!isPlainObject(parsed)) throw new Error("Machine input must be a JSON object.");
+  if (!isPlainObject2(parsed)) throw new Error("Machine input must be a JSON object.");
   return parsed;
 }
 function inputDigest(input) {
@@ -17316,7 +17755,7 @@ function inputDigest(input) {
 }
 function canonicalJson(value) {
   if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
-  if (isPlainObject(value)) {
+  if (isPlainObject2(value)) {
     return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`).join(",")}}`;
   }
   return JSON.stringify(value);
@@ -17346,18 +17785,18 @@ function parseTrustedJsonFromFd(fd, predicate) {
   }
 }
 function isTrustedAuth(value) {
-  return isPlainObject(value) && typeof value.token === "string" && value.token.trim() !== "" && typeof value.baseUrl === "string" && value.baseUrl.trim() !== "" && typeof value.organizationId === "string" && value.organizationId.trim() !== "" && typeof value.actorId === "string" && value.actorId.trim() !== "";
+  return isPlainObject2(value) && typeof value.token === "string" && value.token.trim() !== "" && typeof value.baseUrl === "string" && value.baseUrl.trim() !== "" && typeof value.organizationId === "string" && value.organizationId.trim() !== "" && typeof value.actorId === "string" && value.actorId.trim() !== "";
 }
 function isTrustedApproval(value) {
-  return isPlainObject(value) && typeof value.operation === "string" && typeof value.inputDigest === "string" && typeof value.cliVersion === "string" && typeof value.registryDigest === "string" && typeof value.organizationId === "string" && value.organizationId.trim() !== "" && typeof value.actorId === "string" && value.actorId.trim() !== "";
+  return isPlainObject2(value) && typeof value.operation === "string" && typeof value.inputDigest === "string" && typeof value.cliVersion === "string" && typeof value.registryDigest === "string" && typeof value.organizationId === "string" && value.organizationId.trim() !== "" && typeof value.actorId === "string" && value.actorId.trim() !== "";
 }
 function operationCommand(program, id) {
   return listInvocableCommands(program).find((command) => commandId(command) === id);
 }
-function typeMatches(value, type) {
+function typeMatches2(value, type) {
   if (type === "array") return Array.isArray(value);
   if (type === "null") return value === null;
-  if (type === "object") return isPlainObject(value);
+  if (type === "object") return isPlainObject2(value);
   return typeof value === type;
 }
 function validateInput(operation, input) {
@@ -17366,16 +17805,19 @@ function validateInput(operation, input) {
   const missing = operation.inputSchema.required.filter(
     (key) => input[key] === void 0 || input[key] === null || input[key] === ""
   );
-  const typeErrors = Object.entries(input).flatMap(([key, value]) => {
+  const valueErrors = Object.entries(input).flatMap(([key, value]) => {
     const property = operation.inputSchema.properties[key];
     if (!property) return [];
     const types = Array.isArray(property.type) ? property.type : [property.type];
-    return types.some((type) => typeMatches(value, type)) ? [] : [`Invalid input type for ${key}: expected ${types.join(" or ")}.`];
+    if (!types.some((type) => typeMatches2(value, type))) {
+      return [`Invalid input type for ${key}: expected ${types.join(" or ")}.`];
+    }
+    return key === "dataJson" ? validateOperationDataJson(operation.id, value) : [];
   });
   return [
     ...unknown.map((key) => `Unknown input property: ${key}`),
     ...missing.map((key) => `Missing required input property: ${key}`),
-    ...typeErrors
+    ...valueErrors
   ];
 }
 function optionValue(value) {