@lostgradient/weft 0.17.0 → 0.19.0

package/dist/server/operations/get-principal.d.ts

@@ -0,0 +1,75 @@
+/**
+ * `weft.system.principal` operation + REST binding.
+ *
+ * Reports the caller's own resolved principal: the authentication method,
+ * the normalized subject, and the granted scope set. Public access by
+ * design — introspection has to work for every credential state to be
+ * useful (a dashboard probes its principal before it knows anything), and
+ * an unauthenticated caller learns only what it already knows: that it is
+ * anonymous with no scopes. The response is strictly principal-shaped —
+ * nothing about the server's auth configuration (key inventory,
+ * `unauthenticatedAccess` posture, JWT issuers) is exposed.
+ */
+import { z } from 'zod';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const getPrincipalInput: z.ZodObject<{}, z.core.$strip>;
+declare const getPrincipalOutput: z.ZodObject<{
+    method: z.ZodEnum<{
+        jwt: "jwt";
+        "api-key": "api-key";
+        mtls: "mtls";
+        "stdio-local": "stdio-local";
+        unauthenticated: "unauthenticated";
+    }>;
+    subject: z.ZodNullable<z.ZodString>;
+    scopes: z.ZodArray<z.ZodEnum<{
+        "workflows:read": "workflows:read";
+        "workflows:write": "workflows:write";
+        "workflows:admin": "workflows:admin";
+        "schedules:read": "schedules:read";
+        "schedules:write": "schedules:write";
+        "signals:write": "signals:write";
+        "updates:write": "updates:write";
+        "queries:read": "queries:read";
+        "reviews:read": "reviews:read";
+        "reviews:write": "reviews:write";
+        "attributes:read": "attributes:read";
+        "attributes:write": "attributes:write";
+        "tags:write": "tags:write";
+        "streams:read": "streams:read";
+        "events:read": "events:read";
+        "storage:read": "storage:read";
+        "storage:write": "storage:write";
+        "storage:admin": "storage:admin";
+        "workers:write": "workers:write";
+        "system:read": "system:read";
+        "system:admin": "system:admin";
+    }>>;
+}, z.core.$strip>;
+export type GetPrincipalInput = z.infer<typeof getPrincipalInput>;
+/**
+ * Output of `weft.system.principal`: the caller's authentication method,
+ * normalized subject (`null` when the credential carries none), and granted
+ * scopes, sorted. Anonymous callers receive `method: 'unauthenticated'`
+ * with an empty scope list.
+ *
+ * @example
+ * ```ts
+ * import { type GetPrincipalOutput } from '@lostgradient/weft/server';
+ *
+ * const anonymous: GetPrincipalOutput = {
+ *   method: 'unauthenticated',
+ *   subject: null,
+ *   scopes: [],
+ * };
+ * console.log(anonymous.method);
+ * ```
+ */
+export type GetPrincipalOutput = z.infer<typeof getPrincipalOutput>;
+export declare const getPrincipalOperation: import("../operation-catalog.ts").OperationDefinition<Record<string, never>, {
+    method: "jwt" | "api-key" | "mtls" | "stdio-local" | "unauthenticated";
+    subject: string | null;
+    scopes: ("workflows:read" | "workflows:write" | "workflows:admin" | "schedules:read" | "schedules:write" | "signals:write" | "updates:write" | "queries:read" | "reviews:read" | "reviews:write" | "attributes:read" | "attributes:write" | "tags:write" | "streams:read" | "events:read" | "storage:read" | "storage:write" | "storage:admin" | "workers:write" | "system:read" | "system:admin")[];
+}, unknown>;
+export declare const getPrincipalRestBinding: UnknownRestBinding;
+export {};

package/dist/server/operations/get-principal.js

@@ -0,0 +1,41 @@
+import { z } from "zod";
+import { AUTHORIZATION_SCOPES } from "../authorization-scope.js";
+import { shapeOperationFaultAsJson } from "../operation-fault.js";
+import { defineOperation } from "../operation-registry.js";
+const principalMethodSchema = z.enum(["jwt", "api-key", "mtls", "stdio-local", "unauthenticated"]), getPrincipalInput = z.object({}), getPrincipalOutput = z.object({
+  method: principalMethodSchema,
+  subject: z.string().nullable(),
+  scopes: z.array(z.enum(AUTHORIZATION_SCOPES))
+});
+export const getPrincipalOperation = defineOperation({
+  name: "weft.system.principal",
+  mcpExposable: !1,
+  summary: "Report the caller's resolved principal and granted scopes",
+  description: `Report the caller's own resolved principal: the authentication method ('jwt', 'api-key', 'mtls', 'stdio-local', or 'unauthenticated'), the normalized subject when one exists, and the granted authorization scopes, sorted. Public access: an unauthenticated caller receives method 'unauthenticated' with an empty scope list rather than an error, so clients can distinguish "no credential" from "credential with few scopes" without probing ` + "other operations. Reflects only the request credential \u2014 never server auth configuration.",
+  destructive: !1,
+  tags: ["System"],
+  inputSchema: getPrincipalInput,
+  outputSchema: getPrincipalOutput,
+  access: { kind: "public" },
+  discoverable: !0,
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ principal }) => {
+    if (principal.method === "unauthenticated")
+      return { method: "unauthenticated", subject: null, scopes: [] };
+    return {
+      method: principal.method,
+      subject: principal.subject ?? null,
+      scopes: [...principal.scopes].toSorted()
+    };
+  }
+}), getPrincipalRestBinding = {
+  method: "GET",
+  path: "/v1/principal",
+  pathParamNames: [],
+  operationName: "weft.system.principal",
+  inputSources: {},
+  extractInput: async () => ({}),
+  success: { kind: "json", status: 200 },
+  shapeFault: shapeOperationFaultAsJson
+};

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;

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

@@ -1,18 +1,15 @@
 import { z } from "zod";
-import { decode } from "../../core/codec.js";
-import { KEYS } from "../../storage/interface.js";
+import { raiseFault } from "../operation-catalog/raise-fault.js";
 import { defineOperation } from "../operation-registry.js";
+import { commitTaskLedgerDelete } from "../runtime/task-ledger-runtime.js";
+import { canClearDeadLetteredTask } from "../task-ledger-transitions.js";
+import { decodeRemoteTaskRecord } from "../task-ledger.js";
 import {
   calculateExecutionLatencyMs,
   calculateHeartbeatAgeMs,
-  calculateQueueLatencyMs,
-  clearDeadLetteredTaskRecord,
-  isDeadLetteredTaskRecord,
-  isInflightRecord,
-  isQueuedRecord,
-  isResolvedRecord
+  calculateQueueLatencyMs
 } from "../task-state.js";
-const DEFAULT_STALE_QUEUED_AFTER_MS = 60000, DEFAULT_STALE_HEARTBEAT_AFTER_MS = 60000, DEFAULT_RETRY_STORM_MINIMUM_ATTEMPTS = 3, DEFAULT_LIMIT = 50, MAX_LIMIT = 200, RESOLVED_HISTORY_SCAN_LIMIT = 1000, taskDiagnosticKindSchema = z.enum([
+const DEFAULT_STALE_QUEUED_AFTER_MS = 60000, DEFAULT_STALE_HEARTBEAT_AFTER_MS = 60000, DEFAULT_RETRY_STORM_MINIMUM_ATTEMPTS = 3, DEFAULT_LIMIT = 50, MAX_LIMIT = 200, taskDiagnosticKindSchema = z.enum([
   "stuck-queued",
   "stale-inflight",
   "retry-storm",
@@ -31,7 +28,7 @@ const DEFAULT_STALE_QUEUED_AFTER_MS = 60000, DEFAULT_STALE_HEARTBEAT_AFTER_MS =
   queueLatencyMs: z.number().nonnegative().optional(),
   executionLatencyMs: z.number().nonnegative().optional(),
   heartbeatAgeMs: z.number().nonnegative().optional(),
-  lastRequeueReason: z.enum(["visibility-timeout", "worker-disconnect"]).optional(),
+  lastRequeueReason: z.string().optional(),
   resolutionReason: z.string().optional(),
   deadLetteredAt: z.number().nonnegative().optional(),
   deadLetterReason: z.literal("result-resolution-storage-exhausted").optional(),
@@ -105,12 +102,17 @@ export const getTaskDiagnosticsOperation = createGetTaskDiagnosticsOperation(),
     kind: "scoped",
     scopes: { kind: "anyOf", scopes: ["system:admin"] }
   },
-  producibleFaults: [],
+  producibleFaults: ["NotFound"],
   discoverable: !0,
   transports: restOnlyTaskDiagnosticsTransports,
   unknownKeyPolicy: { http: "reject", jsonRpc: "reject" },
   invoke: async ({ input, engine }) => {
-    await clearDeadLetteredTaskRecord(engine.storage, input.operationId);
+    if (!(await commitTaskLedgerDelete(engine.storage, input.operationId, canClearDeadLetteredTask, 1)).ok)
+      raiseFault(clearTaskDeadLetterOperation, {
+        code: "NotFound",
+        message: `No dead-lettered task found for operation "${input.operationId}"`,
+        data: { resource: "task", identifier: input.operationId }
+      });
     return { ok: !0 };
   }
 });
@@ -127,39 +129,19 @@ async function collectTaskDiagnostics({
     retryStorms: 0,
     allWorkersAtCapacity: 0,
     deadLettered: 0
-  }, relevantQueues = new Set, deadLetteredOperationIds = new Set, addItem = (item) => {
+  }, relevantQueues = new Set, addItem = (item) => {
     incrementSummary(summary, item.kind);
     if (items.length < input.limit)
       items.push(item);
   };
-  for await (const record of scanDeadLetterRecords(engine)) {
-    if (!matchesTaskRecordFilter(record, input))
-      continue;
-    deadLetteredOperationIds.add(record.operationId);
-    if (record.queue !== void 0)
-      relevantQueues.add(record.queue);
-    addDeadLetterDiagnostics(record, addItem);
-  }
-  for await (const record of scanQueuedRecords(engine)) {
-    if (!matchesTaskRecordFilter(record, input))
+  for await (const [, value] of engine.storage.scan("task-ledger:")) {
+    const decoded = decodeRemoteTaskRecord(value);
+    if (decoded === null)
       continue;
-    relevantQueues.add(record.queue);
-    addQueuedDiagnostics(record, input, currentTime, addItem);
-  }
-  for await (const record of scanInflightRecords(engine)) {
-    if (!matchesTaskRecordFilter(record, input))
-      continue;
-    if (deadLetteredOperationIds.has(record.operationId))
+    if (!matchesTaskRecordFilter(decoded, input))
       continue;
-    relevantQueues.add(record.queue);
-    addInflightDiagnostics(record, input, currentTime, addItem);
-  }
-  for await (const record of scanResolvedRecords(engine, input)) {
-    if (!matchesTaskRecordFilter(record, input))
-      continue;
-    if (record.queue !== void 0)
-      relevantQueues.add(record.queue);
-    addRetryStormDiagnostic(record, "resolved", input, addItem);
+    relevantQueues.add(decoded.queue);
+    addRecordDiagnostics(decoded, input, currentTime, addItem);
   }
   addCapacityDiagnostics({
     registry,
@@ -170,88 +152,71 @@ async function collectTaskDiagnostics({
   });
   return { items, summary, limit: input.limit };
 }
-async function* scanDeadLetterRecords(engine) {
-  for await (const [, value] of engine.storage.scan(KEYS.operationDeadLetterPrefix())) {
-    const decoded = decode(value);
-    if (isDeadLetteredTaskRecord(decoded))
-      yield decoded;
-  }
-}
-async function* scanQueuedRecords(engine) {
-  for await (const [, value] of engine.storage.scan("op:queued:")) {
-    const decoded = decode(value);
-    if (isQueuedRecord(decoded))
-      yield decoded;
-  }
-}
-async function* scanInflightRecords(engine) {
-  for await (const [, value] of engine.storage.scan("op:inflight:")) {
-    const decoded = decode(value);
-    if (isInflightRecord(decoded))
-      yield decoded;
-  }
-}
-async function* scanResolvedRecords(engine, input) {
-  if (input.operationId !== void 0) {
-    const value = await engine.storage.get(KEYS.operationResolved(input.operationId));
-    if (value === null)
+function addRecordDiagnostics(decoded, input, currentTime, addItem) {
+  switch (decoded.state) {
+    case "queued":
+      if (decoded.availableAt <= currentTime)
+        addQueuedDiagnostics(decoded, input, currentTime, addItem);
+      addRetryStormDiagnostic(decoded, "queued", input, addItem);
       return;
-    const decoded = decode(value);
-    if (isResolvedRecord(decoded))
-      yield decoded;
-    return;
-  }
-  for await (const [, value] of engine.storage.scan(KEYS.operationResolvedByTimePrefix(), {
-    limit: RESOLVED_HISTORY_SCAN_LIMIT,
-    reverse: !0
-  })) {
-    const decoded = decode(value);
-    if (isResolvedRecord(decoded))
-      yield decoded;
+    case "leased":
+    case "completing":
+    case "cancelling":
+      addInflightDiagnostics(decoded, input, currentTime, addItem);
+      addRetryStormDiagnostic(decoded, "inflight", input, addItem);
+      return;
+    case "terminal":
+      return;
+    case "deadLettered":
+      addDeadLetterDiagnostics(decoded, addItem);
+      return;
+    default: {
+      const exhaustive = decoded;
+    }
   }
 }
 function addQueuedDiagnostics(record, input, currentTime, addItem) {
-  const queuedAt = record.lastQueuedAt ?? record.queuedAt, queueLatencyMs = Math.max(0, currentTime - queuedAt);
-  if (queueLatencyMs >= input.staleQueuedAfterMs)
-    addItem({
-      kind: "stuck-queued",
-      state: "queued",
-      operationId: record.operationId,
-      workflowId: record.workflowId,
-      activityName: record.activityName,
-      queue: record.queue,
-      retryCount: record.retryCount ?? Math.max(0, (record.attempt ?? 1) - 1),
-      requeueCount: record.requeueCount ?? 0,
-      queueLatencyMs,
-      lastRequeueReason: record.lastRequeueReason,
-      evidence: [
-        `Task has waited ${queueLatencyMs}ms in queue "${record.queue}" without a worker claim`
-      ]
-    });
-  addRetryStormDiagnostic(record, "queued", input, addItem);
+  const queueLatencyMs = Math.max(0, currentTime - record.lastQueuedAt);
+  if (queueLatencyMs < input.staleQueuedAfterMs)
+    return;
+  addItem({
+    kind: "stuck-queued",
+    state: "queued",
+    operationId: record.operationId,
+    workflowId: record.workflowId,
+    activityName: record.activityName,
+    queue: record.queue,
+    retryCount: record.retryCount,
+    requeueCount: record.requeueCount,
+    queueLatencyMs,
+    lastRequeueReason: record.lastRequeueReason,
+    evidence: [
+      `Task has waited ${queueLatencyMs}ms in queue "${record.queue}" without a worker claim`
+    ]
+  });
 }
 function addInflightDiagnostics(record, input, currentTime, addItem) {
   const heartbeatAgeMs = calculateHeartbeatAgeMs(record, currentTime) ?? 0;
-  if (heartbeatAgeMs >= input.staleHeartbeatAfterMs)
-    addItem({
-      kind: "stale-inflight",
-      state: "inflight",
-      operationId: record.operationId,
-      workflowId: record.workflowId,
-      activityName: record.activityName,
-      queue: record.queue,
-      workerId: record.workerId,
-      retryCount: record.retryCount ?? Math.max(0, (record.attempt ?? 1) - 1),
-      requeueCount: record.requeueCount ?? 0,
-      queueLatencyMs: calculateQueueLatencyMs(record),
-      executionLatencyMs: calculateExecutionLatencyMs(record, currentTime),
-      heartbeatAgeMs,
-      lastRequeueReason: record.lastRequeueReason,
-      evidence: [
-        `Worker "${record.workerId}" has not sent a heartbeat for ${heartbeatAgeMs}ms on queue "${record.queue}"`
-      ]
-    });
-  addRetryStormDiagnostic(record, "inflight", input, addItem);
+  if (heartbeatAgeMs < input.staleHeartbeatAfterMs)
+    return;
+  addItem({
+    kind: "stale-inflight",
+    state: "inflight",
+    operationId: record.operationId,
+    workflowId: record.workflowId,
+    activityName: record.activityName,
+    queue: record.queue,
+    workerId: record.workerSessionId,
+    retryCount: record.retryCount,
+    requeueCount: record.requeueCount,
+    queueLatencyMs: calculateQueueLatencyMs(record),
+    executionLatencyMs: calculateExecutionLatencyMs(record, currentTime),
+    heartbeatAgeMs,
+    lastRequeueReason: record.lastRequeueReason,
+    evidence: [
+      `Worker "${record.workerSessionId}" has not sent a heartbeat for ${heartbeatAgeMs}ms on queue "${record.queue}"`
+    ]
+  });
 }
 function addDeadLetterDiagnostics(record, addItem) {
   addItem({
@@ -261,21 +226,19 @@ function addDeadLetterDiagnostics(record, addItem) {
     workflowId: record.workflowId,
     activityName: record.activityName,
     queue: record.queue,
-    workerId: record.workerId,
-    retryCount: record.retryCount ?? Math.max(0, (record.attempt ?? 1) - 1),
-    requeueCount: record.requeueCount ?? 0,
+    retryCount: record.retryCount,
+    requeueCount: record.requeueCount,
     lastRequeueReason: record.lastRequeueReason,
     deadLetteredAt: record.deadLetteredAt,
-    deadLetterReason: record.reason,
-    storageError: record.errorMessage,
-    retryAttempts: record.retryAttempts,
+    deadLetterReason: "result-resolution-storage-exhausted",
+    storageError: record.persistenceFailureReason,
     evidence: [
-      `Task result transition exhausted ${record.retryAttempts} storage attempts; reconciliation will not re-dispatch operation "${record.operationId}" until the dead-letter entry is cleared`
+      `Task result could not be durably persisted (${record.persistenceFailureReason}); reconciliation will not re-dispatch operation "${record.operationId}" until the dead-letter entry is cleared`
     ]
   });
 }
 function addRetryStormDiagnostic(record, state, input, addItem) {
-  const retryCount = record.retryCount ?? Math.max(0, (record.attempt ?? 1) - 1), requeueCount = record.requeueCount ?? 0;
+  const { retryCount, requeueCount } = record;
   if (retryCount < input.retryStormMinimumAttempts && requeueCount < input.retryStormMinimumAttempts)
     return;
   addItem({
@@ -283,15 +246,13 @@ function addRetryStormDiagnostic(record, state, input, addItem) {
     state,
     operationId: record.operationId,
     workflowId: record.workflowId,
-    activityName: "activityName" in record ? record.activityName : void 0,
+    activityName: record.activityName,
     queue: record.queue,
-    workerId: "workerId" in record ? record.workerId : void 0,
+    workerId: "workerSessionId" in record ? record.workerSessionId : void 0,
     retryCount,
     requeueCount,
     queueLatencyMs: calculateQueueLatencyMs(record),
-    executionLatencyMs: "resolvedAt" in record ? calculateExecutionLatencyMs(record, record.resolvedAt) : void 0,
     lastRequeueReason: record.lastRequeueReason,
-    resolutionReason: "resolutionReason" in record ? record.resolutionReason : void 0,
     evidence: [
       `Task has ${retryCount} retries and ${requeueCount} requeues, meeting retry storm threshold ${input.retryStormMinimumAttempts}`
     ]