@lostgradient/weft 0.18.0 → 0.20.0

package/dist/server/operations/get-task-detail.d.ts

@@ -0,0 +1,346 @@
+/**
+ * `weft.tasks.get` operation + REST binding (WFT-92).
+ *
+ * Reads the full durable ledger state for one `operationId` — the wire
+ * counterpart to `WeftServer.getTaskResult()`, which is same-process-only
+ * (`src/server/runtime/task-result-view.ts`). This operation exposes the
+ * complete dispatch envelope and current ledger state so an HTTP/JSON-RPC
+ * caller — an operator console, for instance — can render one task's
+ * authoritative state without reconstructing it from the bounded
+ * `weft.tasks.diagnostics` alerting shape, which deliberately collapses
+ * `leased`/`completing`/`cancelling` into one `inflight` value and carries
+ * no attempt identity, priority, headers, retry-availability, adoption, or
+ * retention evidence.
+ *
+ * **Excluded fields.** `attemptToken`, `workerSessionId`, and
+ * `executionIdentity` are never projected here, matching
+ * `TaskResultView`'s own documented exclusion list — they are worker
+ * ownership/session internals with no business being public. `headers`
+ * are summarized as key names only (`headerKeys`): interceptor headers can
+ * carry trace context or auth material, and this is a read surface, not a
+ * payload inspector. The task `input` value and a dead-lettered record's
+ * pending result `value` are omitted for the same "digest not value"
+ * reason `TaskResultView` omits a resolved result's value — the ledger
+ * proves which attempt won, it does not re-deliver payloads. `resultDigest`
+ * is only projected for `disposition: 'resolved'`: the `cancelled`
+ * (mid-attempt) and `retryExhausted` lineages store a synthetic
+ * `${disposition}:${operationId}:${attemptToken}` placeholder there instead
+ * of a real content hash (`task-ledger-transitions(-cancellation).ts`),
+ * which would otherwise leak the excluded `attemptToken` verbatim.
+ *
+ * **Read-only by design.** This issue deliberately does not add an HTTP
+ * path to `adoptTaskResultImpl`. WFT-24 describes adoption as "an explicit
+ * caller assertion" that a workflow incorporated a result — a browser
+ * operator clicking a button cannot honestly make that assertion. If an
+ * HTTP adoption path is ever wanted, it needs its own design discussion,
+ * not a bundled addition here.
+ *
+ * @module server/operations/get-task-detail
+ */
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+export { executionRequirementSchema, getTaskDetailOutputSchema, retryPolicySchema, type GetTaskDetailInput, type GetTaskDetailOutput, } from './get-task-detail-schema.ts';
+export declare const getTaskDetailOperation: import("../operation-catalog.ts").OperationDefinition<{
+    operationId: string;
+}, {
+    disposition: "resolved";
+    resultDigest: string;
+    resultStatus: "completed" | "failed";
+    state: "terminal";
+    terminalAt: number;
+    adopted: boolean;
+    operationId: string;
+    workflowType: string;
+    activityName: string;
+    queue: string;
+    headerKeys: string[];
+    visibilityTimeoutMilliseconds: number;
+    createdAt: number;
+    attempt: number;
+    error?: string | undefined;
+    adoptedAt?: number | undefined;
+    workflowId?: string | undefined;
+    workflowExecutionToken?: string | undefined;
+    priority?: number | undefined;
+    retryPolicy?: {
+        maxAttempts: number;
+        initialBackoff: string | number;
+        backoffMultiplier: number;
+        maxBackoff: string | number;
+        nonRetryableErrors?: string[] | undefined;
+    } | undefined;
+    scheduleToCloseDeadline?: number | undefined;
+    executionRequirement?: {
+        deploymentName?: string | undefined;
+        buildId?: string | undefined;
+        artifactDigest?: string | undefined;
+        workflowRevision?: string | undefined;
+        activityContractHash?: string | undefined;
+    } | undefined;
+    fairShareKey?: string | undefined;
+    stickyWorkflowId?: string | undefined;
+} | {
+    disposition: "cancelled";
+    cancellationReason: string;
+    state: "terminal";
+    terminalAt: number;
+    adopted: boolean;
+    operationId: string;
+    workflowType: string;
+    activityName: string;
+    queue: string;
+    headerKeys: string[];
+    visibilityTimeoutMilliseconds: number;
+    createdAt: number;
+    attempt: number;
+    adoptedAt?: number | undefined;
+    workflowId?: string | undefined;
+    workflowExecutionToken?: string | undefined;
+    priority?: number | undefined;
+    retryPolicy?: {
+        maxAttempts: number;
+        initialBackoff: string | number;
+        backoffMultiplier: number;
+        maxBackoff: string | number;
+        nonRetryableErrors?: string[] | undefined;
+    } | undefined;
+    scheduleToCloseDeadline?: number | undefined;
+    executionRequirement?: {
+        deploymentName?: string | undefined;
+        buildId?: string | undefined;
+        artifactDigest?: string | undefined;
+        workflowRevision?: string | undefined;
+        activityContractHash?: string | undefined;
+    } | undefined;
+    fairShareKey?: string | undefined;
+    stickyWorkflowId?: string | undefined;
+} | {
+    disposition: "retryExhausted";
+    error: string;
+    state: "terminal";
+    terminalAt: number;
+    adopted: boolean;
+    operationId: string;
+    workflowType: string;
+    activityName: string;
+    queue: string;
+    headerKeys: string[];
+    visibilityTimeoutMilliseconds: number;
+    createdAt: number;
+    attempt: number;
+    adoptedAt?: number | undefined;
+    workflowId?: string | undefined;
+    workflowExecutionToken?: string | undefined;
+    priority?: number | undefined;
+    retryPolicy?: {
+        maxAttempts: number;
+        initialBackoff: string | number;
+        backoffMultiplier: number;
+        maxBackoff: string | number;
+        nonRetryableErrors?: string[] | undefined;
+    } | undefined;
+    scheduleToCloseDeadline?: number | undefined;
+    executionRequirement?: {
+        deploymentName?: string | undefined;
+        buildId?: string | undefined;
+        artifactDigest?: string | undefined;
+        workflowRevision?: string | undefined;
+        activityContractHash?: string | undefined;
+    } | undefined;
+    fairShareKey?: string | undefined;
+    stickyWorkflowId?: string | undefined;
+} | {
+    state: "queued";
+    availableAt: number;
+    firstQueuedAt: number;
+    lastQueuedAt: number;
+    retryCount: number;
+    requeueCount: number;
+    operationId: string;
+    workflowType: string;
+    activityName: string;
+    queue: string;
+    headerKeys: string[];
+    visibilityTimeoutMilliseconds: number;
+    createdAt: number;
+    attempt: number;
+    lastDispatchedAt?: number | undefined;
+    startedAt?: number | undefined;
+    lastRequeueReason?: string | undefined;
+    workflowId?: string | undefined;
+    workflowExecutionToken?: string | undefined;
+    priority?: number | undefined;
+    retryPolicy?: {
+        maxAttempts: number;
+        initialBackoff: string | number;
+        backoffMultiplier: number;
+        maxBackoff: string | number;
+        nonRetryableErrors?: string[] | undefined;
+    } | undefined;
+    scheduleToCloseDeadline?: number | undefined;
+    executionRequirement?: {
+        deploymentName?: string | undefined;
+        buildId?: string | undefined;
+        artifactDigest?: string | undefined;
+        workflowRevision?: string | undefined;
+        activityContractHash?: string | undefined;
+    } | undefined;
+    fairShareKey?: string | undefined;
+    stickyWorkflowId?: string | undefined;
+} | {
+    leaseDeadline: number;
+    firstQueuedAt: number;
+    lastQueuedAt: number;
+    startedAt: number;
+    lastHeartbeatAt: number;
+    state: "leased";
+    retryCount: number;
+    requeueCount: number;
+    operationId: string;
+    workflowType: string;
+    activityName: string;
+    queue: string;
+    headerKeys: string[];
+    visibilityTimeoutMilliseconds: number;
+    createdAt: number;
+    attempt: number;
+    lastRequeueReason?: string | undefined;
+    workflowId?: string | undefined;
+    workflowExecutionToken?: string | undefined;
+    priority?: number | undefined;
+    retryPolicy?: {
+        maxAttempts: number;
+        initialBackoff: string | number;
+        backoffMultiplier: number;
+        maxBackoff: string | number;
+        nonRetryableErrors?: string[] | undefined;
+    } | undefined;
+    scheduleToCloseDeadline?: number | undefined;
+    executionRequirement?: {
+        deploymentName?: string | undefined;
+        buildId?: string | undefined;
+        artifactDigest?: string | undefined;
+        workflowRevision?: string | undefined;
+        activityContractHash?: string | undefined;
+    } | undefined;
+    fairShareKey?: string | undefined;
+    stickyWorkflowId?: string | undefined;
+} | {
+    pendingStatus: "completed" | "failed";
+    resultDigest: string;
+    leaseDeadline: number;
+    firstQueuedAt: number;
+    lastQueuedAt: number;
+    startedAt: number;
+    lastHeartbeatAt: number;
+    state: "completing";
+    retryCount: number;
+    requeueCount: number;
+    operationId: string;
+    workflowType: string;
+    activityName: string;
+    queue: string;
+    headerKeys: string[];
+    visibilityTimeoutMilliseconds: number;
+    createdAt: number;
+    attempt: number;
+    lastRequeueReason?: string | undefined;
+    workflowId?: string | undefined;
+    workflowExecutionToken?: string | undefined;
+    priority?: number | undefined;
+    retryPolicy?: {
+        maxAttempts: number;
+        initialBackoff: string | number;
+        backoffMultiplier: number;
+        maxBackoff: string | number;
+        nonRetryableErrors?: string[] | undefined;
+    } | undefined;
+    scheduleToCloseDeadline?: number | undefined;
+    executionRequirement?: {
+        deploymentName?: string | undefined;
+        buildId?: string | undefined;
+        artifactDigest?: string | undefined;
+        workflowRevision?: string | undefined;
+        activityContractHash?: string | undefined;
+    } | undefined;
+    fairShareKey?: string | undefined;
+    stickyWorkflowId?: string | undefined;
+} | {
+    cancellationReason: string;
+    cancellationRequestedAt: number;
+    leaseDeadline: number;
+    firstQueuedAt: number;
+    lastQueuedAt: number;
+    startedAt: number;
+    lastHeartbeatAt: number;
+    state: "cancelling";
+    retryCount: number;
+    requeueCount: number;
+    operationId: string;
+    workflowType: string;
+    activityName: string;
+    queue: string;
+    headerKeys: string[];
+    visibilityTimeoutMilliseconds: number;
+    createdAt: number;
+    attempt: number;
+    lastRequeueReason?: string | undefined;
+    workflowId?: string | undefined;
+    workflowExecutionToken?: string | undefined;
+    priority?: number | undefined;
+    retryPolicy?: {
+        maxAttempts: number;
+        initialBackoff: string | number;
+        backoffMultiplier: number;
+        maxBackoff: string | number;
+        nonRetryableErrors?: string[] | undefined;
+    } | undefined;
+    scheduleToCloseDeadline?: number | undefined;
+    executionRequirement?: {
+        deploymentName?: string | undefined;
+        buildId?: string | undefined;
+        artifactDigest?: string | undefined;
+        workflowRevision?: string | undefined;
+        activityContractHash?: string | undefined;
+    } | undefined;
+    fairShareKey?: string | undefined;
+    stickyWorkflowId?: string | undefined;
+} | {
+    state: "deadLettered";
+    pendingStatus: "completed" | "failed";
+    resultDigest: string;
+    deadLetteredAt: number;
+    persistenceFailureReason: string;
+    retryCount: number;
+    requeueCount: number;
+    operationId: string;
+    workflowType: string;
+    activityName: string;
+    queue: string;
+    headerKeys: string[];
+    visibilityTimeoutMilliseconds: number;
+    createdAt: number;
+    attempt: number;
+    error?: string | undefined;
+    lastRequeueReason?: string | undefined;
+    workflowId?: string | undefined;
+    workflowExecutionToken?: string | undefined;
+    priority?: number | undefined;
+    retryPolicy?: {
+        maxAttempts: number;
+        initialBackoff: string | number;
+        backoffMultiplier: number;
+        maxBackoff: string | number;
+        nonRetryableErrors?: string[] | undefined;
+    } | undefined;
+    scheduleToCloseDeadline?: number | undefined;
+    executionRequirement?: {
+        deploymentName?: string | undefined;
+        buildId?: string | undefined;
+        artifactDigest?: string | undefined;
+        workflowRevision?: string | undefined;
+        activityContractHash?: string | undefined;
+    } | undefined;
+    fairShareKey?: string | undefined;
+    stickyWorkflowId?: string | undefined;
+}, unknown>;
+export declare const getTaskDetailRestBinding: UnknownRestBinding;

package/dist/server/operations/get-task-detail.js

@@ -0,0 +1,215 @@
+import { raiseFault } from "../operation-catalog/raise-fault.js";
+import { defineOperation } from "../operation-registry.js";
+import {
+  decodeRemoteTaskRecord,
+  taskLedgerKey
+} from "../task-ledger.js";
+import {
+  executionRequirementSchema,
+  getTaskDetailInput,
+  getTaskDetailOutputSchema,
+  retryPolicySchema
+} from "./get-task-detail-schema.js";
+export {
+  executionRequirementSchema,
+  getTaskDetailOutputSchema,
+  retryPolicySchema
+} from "./get-task-detail-schema.js";
+function projectRetryPolicy(retryPolicy) {
+  return {
+    maxAttempts: retryPolicy.maxAttempts,
+    initialBackoff: retryPolicy.initialBackoff,
+    backoffMultiplier: retryPolicy.backoffMultiplier,
+    maxBackoff: retryPolicy.maxBackoff,
+    ...retryPolicy.nonRetryableErrors !== void 0 ? { nonRetryableErrors: retryPolicy.nonRetryableErrors } : {}
+  };
+}
+function projectExecutionRequirement(executionRequirement) {
+  return {
+    ...executionRequirement.deploymentName !== void 0 ? { deploymentName: executionRequirement.deploymentName } : {},
+    ...executionRequirement.buildId !== void 0 ? { buildId: executionRequirement.buildId } : {},
+    ...executionRequirement.artifactDigest !== void 0 ? { artifactDigest: executionRequirement.artifactDigest } : {},
+    ...executionRequirement.workflowRevision !== void 0 ? { workflowRevision: executionRequirement.workflowRevision } : {},
+    ...executionRequirement.activityContractHash !== void 0 ? { activityContractHash: executionRequirement.activityContractHash } : {}
+  };
+}
+function baseEnvelopeFields(record) {
+  return {
+    operationId: record.operationId,
+    ...record.workflowId !== void 0 ? { workflowId: record.workflowId } : {},
+    ...record.workflowExecutionToken !== void 0 ? { workflowExecutionToken: record.workflowExecutionToken } : {},
+    workflowType: record.workflowType,
+    activityName: record.activityName,
+    queue: record.queue,
+    ...record.priority !== void 0 ? { priority: record.priority } : {},
+    headerKeys: Object.keys(record.headers),
+    visibilityTimeoutMilliseconds: record.visibilityTimeoutMilliseconds,
+    ...record.retryPolicy !== void 0 ? { retryPolicy: projectRetryPolicy(record.retryPolicy) } : {},
+    ...record.scheduleToCloseDeadline !== void 0 ? { scheduleToCloseDeadline: record.scheduleToCloseDeadline } : {},
+    ...record.executionRequirement !== void 0 ? { executionRequirement: projectExecutionRequirement(record.executionRequirement) } : {},
+    ...record.fairShareKey !== void 0 ? { fairShareKey: record.fairShareKey } : {},
+    ...record.stickyWorkflowId !== void 0 ? { stickyWorkflowId: record.stickyWorkflowId } : {},
+    createdAt: record.createdAt,
+    attempt: record.attempt
+  };
+}
+function attemptFields(record) {
+  return {
+    retryCount: record.retryCount,
+    requeueCount: record.requeueCount,
+    ...record.lastRequeueReason !== void 0 ? { lastRequeueReason: record.lastRequeueReason } : {}
+  };
+}
+function leaseHolderFields(record) {
+  return {
+    leaseDeadline: record.leaseDeadline,
+    firstQueuedAt: record.firstQueuedAt,
+    lastQueuedAt: record.lastQueuedAt,
+    startedAt: record.startedAt,
+    lastHeartbeatAt: record.lastHeartbeatAt
+  };
+}
+function projectQueued(record) {
+  return {
+    ...baseEnvelopeFields(record),
+    ...attemptFields(record),
+    state: "queued",
+    availableAt: record.availableAt,
+    firstQueuedAt: record.firstQueuedAt,
+    lastQueuedAt: record.lastQueuedAt,
+    ...record.lastDispatchedAt !== void 0 ? { lastDispatchedAt: record.lastDispatchedAt } : {},
+    ...record.startedAt !== void 0 ? { startedAt: record.startedAt } : {}
+  };
+}
+function projectLeased(record) {
+  return {
+    ...baseEnvelopeFields(record),
+    ...attemptFields(record),
+    ...leaseHolderFields(record),
+    state: "leased"
+  };
+}
+function projectCompleting(record) {
+  return {
+    ...baseEnvelopeFields(record),
+    ...attemptFields(record),
+    ...leaseHolderFields(record),
+    state: "completing",
+    pendingStatus: record.pendingStatus,
+    resultDigest: record.pendingResultDigest
+  };
+}
+function projectCancelling(record) {
+  return {
+    ...baseEnvelopeFields(record),
+    ...attemptFields(record),
+    ...leaseHolderFields(record),
+    state: "cancelling",
+    cancellationReason: record.cancellationReason,
+    cancellationRequestedAt: record.cancellationRequestedAt
+  };
+}
+function terminalDispositionFields(record) {
+  if (record.disposition === "resolved")
+    return {
+      disposition: "resolved",
+      resultDigest: record.resultDigest,
+      resultStatus: record.status,
+      ...record.error !== void 0 ? { error: record.error } : {}
+    };
+  if (record.disposition === "cancelled")
+    return {
+      disposition: "cancelled",
+      cancellationReason: record.cancellationReason
+    };
+  return {
+    disposition: "retryExhausted",
+    error: record.error
+  };
+}
+function projectTerminal(record) {
+  return {
+    ...baseEnvelopeFields(record),
+    state: "terminal",
+    terminalAt: record.terminalAt,
+    adopted: record.adopted,
+    ...record.adoptedAt !== void 0 ? { adoptedAt: record.adoptedAt } : {},
+    ...terminalDispositionFields(record)
+  };
+}
+function projectDeadLettered(record) {
+  return {
+    ...baseEnvelopeFields(record),
+    ...attemptFields(record),
+    state: "deadLettered",
+    pendingStatus: record.pendingStatus,
+    resultDigest: record.pendingResultDigest,
+    deadLetteredAt: record.deadLetteredAt,
+    persistenceFailureReason: record.persistenceFailureReason,
+    ...record.error !== void 0 ? { error: record.error } : {}
+  };
+}
+function projectTaskDetail(record) {
+  switch (record.state) {
+    case "queued":
+      return projectQueued(record);
+    case "leased":
+      return projectLeased(record);
+    case "completing":
+      return projectCompleting(record);
+    case "cancelling":
+      return projectCancelling(record);
+    case "terminal":
+      return projectTerminal(record);
+    case "deadLettered":
+      return projectDeadLettered(record);
+    default:
+      return record;
+  }
+}
+export const getTaskDetailOperation = defineOperation({
+  name: "weft.tasks.get",
+  mcpExposable: !1,
+  summary: "Get one task's full durable ledger state",
+  destructive: !1,
+  tags: ["Observability"],
+  inputSchema: getTaskDetailInput,
+  outputSchema: getTaskDetailOutputSchema,
+  access: {
+    kind: "scoped",
+    scopes: { kind: "anyOf", scopes: ["system:read"] }
+  },
+  producibleFaults: ["NotFound"],
+  discoverable: !0,
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine }) => {
+    const raw = await engine.storage.get(taskLedgerKey(input.operationId));
+    if (raw === null)
+      raiseFault(getTaskDetailOperation, {
+        code: "NotFound",
+        message: `No task found for operation "${input.operationId}"`,
+        data: { resource: "task", identifier: input.operationId }
+      });
+    const decoded = decodeRemoteTaskRecord(raw);
+    if (decoded === null || decoded.operationId !== input.operationId)
+      raiseFault(getTaskDetailOperation, {
+        code: "EngineFailure",
+        message: `Task ledger record for operation "${input.operationId}" could not be decoded`,
+        data: {}
+      });
+    return projectTaskDetail(decoded);
+  }
+}), getTaskDetailRestBinding = {
+  method: "GET",
+  path: "/v1/tasks/detail/:operationId",
+  pathParamNames: ["operationId"],
+  operationName: "weft.tasks.get",
+  inputSources: {
+    operationId: { kind: "path", pathParam: "operationId" }
+  },
+  extractInput: async (_request, pathParams) => ({
+    operationId: pathParams.operationId ?? ""
+  }),
+  success: { kind: "json", status: 200 }
+};

package/dist/server/operations/get-task-diagnostics.d.ts

@@ -1,10 +1,41 @@
 /**
  * `weft.tasks.diagnostics` operation + REST binding.
  *
- * Scans durable task records and live worker state to identify queue pressure,
- * stale in-flight work, retry storms, and worker capacity saturation. Results
- * are intentionally bounded and low-cardinality so operators can use them in a
- * dashboard without turning workflow or worker identifiers into metrics labels.
+ * Scans the durable task ledger (WFT-24 — previously the retired
+ * `op:queued:`/`op:inflight:`/`op:resolved:`/`op:dead-letter:` keys, which
+ * nothing has written since the WFT-22 ledger cutover) and live worker state
+ * to identify queue pressure, stale in-flight work, retry storms, dead
+ * letters, and worker capacity saturation. Results are intentionally bounded
+ * and low-cardinality so operators can use them in a dashboard without
+ * turning workflow or worker identifiers into metrics labels.
+ *
+ * The output schema's field names and `kind`/`state` vocabulary are
+ * unchanged from the pre-ledger version — only the internal scan and
+ * classification logic changed — so existing dashboards built against this
+ * endpoint's shape keep working. `leased`, `completing`, and `cancelling`
+ * ledger states are all reported as diagnostic `state: 'inflight'`: they
+ * share the same lease-holder/heartbeat shape and the same operator
+ * question ("is a worker still making progress on this attempt?"), so
+ * exposing the ledger's more granular internal states here would add
+ * distinctions operators cannot act on differently.
+ *
+ * Retry-storm detection (`kind: 'retry-storm'`) no longer covers `terminal`
+ * records: `RemoteTaskTerminal` carries no `retryCount`/`requeueCount` (WFT-25
+ * deliberately dropped attempt-count history once a task resolves), so
+ * there is nothing left to detect a storm from once an attempt reaches a
+ * disposition. The `resolved` value in the `state` enum is kept in the
+ * output schema for backward compatibility but nothing produces it anymore.
+ * `dead-lettered` diagnostics are unaffected — that is a distinct, separate
+ * `kind`.
+ *
+ * Unlike the pre-ledger scan, the full ledger scan this operation performs
+ * is one combined keyspace across every state (queued through terminal),
+ * not separate per-state prefixes — there is no time-bounded history index
+ * to limit how many terminal records get walked past on the way to
+ * classifying the ones that still matter. Operators who dispatch high
+ * volumes of tasks and want this scan to stay cheap should set
+ * {@link ServeOptions.taskRetentionWindowMs} so adopted terminal records
+ * are reaped rather than accumulating indefinitely.
  *
  * @module server/operations/get-task-diagnostics
  */
@@ -30,8 +61,8 @@ declare const taskDiagnosticItemSchema: z.ZodObject<{
     state: z.ZodEnum<{
         "dead-lettered": "dead-lettered";
         queued: "queued";
-        inflight: "inflight";
         resolved: "resolved";
+        inflight: "inflight";
         capacity: "capacity";
     }>;
     operationId: z.ZodOptional<z.ZodString>;
@@ -44,10 +75,7 @@ declare const taskDiagnosticItemSchema: z.ZodObject<{
     queueLatencyMs: z.ZodOptional<z.ZodNumber>;
     executionLatencyMs: z.ZodOptional<z.ZodNumber>;
     heartbeatAgeMs: z.ZodOptional<z.ZodNumber>;
-    lastRequeueReason: z.ZodOptional<z.ZodEnum<{
-        "visibility-timeout": "visibility-timeout";
-        "worker-disconnect": "worker-disconnect";
-    }>>;
+    lastRequeueReason: z.ZodOptional<z.ZodString>;
     resolutionReason: z.ZodOptional<z.ZodString>;
     deadLetteredAt: z.ZodOptional<z.ZodNumber>;
     deadLetterReason: z.ZodOptional<z.ZodLiteral<"result-resolution-storage-exhausted">>;
@@ -74,8 +102,8 @@ declare const getTaskDiagnosticsOutput: z.ZodObject<{
         state: z.ZodEnum<{
             "dead-lettered": "dead-lettered";
             queued: "queued";
-            inflight: "inflight";
             resolved: "resolved";
+            inflight: "inflight";
             capacity: "capacity";
         }>;
         operationId: z.ZodOptional<z.ZodString>;
@@ -88,10 +116,7 @@ declare const getTaskDiagnosticsOutput: z.ZodObject<{
         queueLatencyMs: z.ZodOptional<z.ZodNumber>;
         executionLatencyMs: z.ZodOptional<z.ZodNumber>;
         heartbeatAgeMs: z.ZodOptional<z.ZodNumber>;
-        lastRequeueReason: z.ZodOptional<z.ZodEnum<{
-            "visibility-timeout": "visibility-timeout";
-            "worker-disconnect": "worker-disconnect";
-        }>>;
+        lastRequeueReason: z.ZodOptional<z.ZodString>;
         resolutionReason: z.ZodOptional<z.ZodString>;
         deadLetteredAt: z.ZodOptional<z.ZodNumber>;
         deadLetterReason: z.ZodOptional<z.ZodLiteral<"result-resolution-storage-exhausted">>;
@@ -146,7 +171,7 @@ export declare function createGetTaskDiagnosticsOperation(options?: GetTaskDiagn
 }, {
     items: {
         kind: "dead-lettered" | "stuck-queued" | "stale-inflight" | "retry-storm" | "all-workers-at-capacity";
-        state: "dead-lettered" | "queued" | "inflight" | "resolved" | "capacity";
+        state: "dead-lettered" | "queued" | "resolved" | "inflight" | "capacity";
         retryCount: number;
         requeueCount: number;
         evidence: string[];
@@ -158,7 +183,7 @@ export declare function createGetTaskDiagnosticsOperation(options?: GetTaskDiagn
         queueLatencyMs?: number | undefined;
         executionLatencyMs?: number | undefined;
         heartbeatAgeMs?: number | undefined;
-        lastRequeueReason?: "visibility-timeout" | "worker-disconnect" | undefined;
+        lastRequeueReason?: string | undefined;
         resolutionReason?: string | undefined;
         deadLetteredAt?: number | undefined;
         deadLetterReason?: "result-resolution-storage-exhausted" | undefined;
@@ -185,7 +210,7 @@ export declare const getTaskDiagnosticsOperation: import("../operation-catalog.t
 }, {
     items: {
         kind: "dead-lettered" | "stuck-queued" | "stale-inflight" | "retry-storm" | "all-workers-at-capacity";
-        state: "dead-lettered" | "queued" | "inflight" | "resolved" | "capacity";
+        state: "dead-lettered" | "queued" | "resolved" | "inflight" | "capacity";
         retryCount: number;
         requeueCount: number;
         evidence: string[];
@@ -197,7 +222,7 @@ export declare const getTaskDiagnosticsOperation: import("../operation-catalog.t
         queueLatencyMs?: number | undefined;
         executionLatencyMs?: number | undefined;
         heartbeatAgeMs?: number | undefined;
-        lastRequeueReason?: "visibility-timeout" | "worker-disconnect" | undefined;
+        lastRequeueReason?: string | undefined;
         resolutionReason?: string | undefined;
         deadLetteredAt?: number | undefined;
         deadLetterReason?: "result-resolution-storage-exhausted" | undefined;