@lostgradient/weft 0.18.0 → 0.20.0

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}`
     ]

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

@@ -0,0 +1,177 @@
+/**
+ * `weft.workers.diagnostics` operation + REST binding.
+ *
+ * Bounded diagnostic detail for one connected worker (WFT-29), split into
+ * two structurally distinct sub-objects: `instance` (this live socket —
+ * queue, health, connection timestamps) and `deploymentVersion` (what
+ * artifact it loaded — SDK/runtime identity, manifest digest, and every
+ * advertised workflow's version/revision/contract hash). Keeping these
+ * separate mirrors the manifest's own split between "which process" and
+ * "which build" questions.
+ *
+ * Deliberately excludes `capabilities` and the raw payload schemas backing
+ * each `contractHash` — this surfaces identity for drift detection, not a
+ * schema dump.
+ *
+ * @module server/operations/get-worker-diagnostics
+ */
+import { z } from 'zod';
+import type { WorkerHealth, WorkerRegistry } from '../../worker/registry.ts';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const workerDiagnosticsEntrySchema: z.ZodObject<{
+    instance: z.ZodObject<{
+        workerId: z.ZodString;
+        queue: z.ZodString;
+        health: z.ZodType<WorkerHealth, unknown, z.core.$ZodTypeInternals<WorkerHealth, unknown>>;
+        connectedAt: z.ZodNumber;
+        startedAt: z.ZodNumber;
+        lastHeartbeatAt: z.ZodNumber;
+        heartbeatAgeMs: z.ZodNumber;
+    }, z.core.$strict>;
+    deploymentVersion: z.ZodObject<{
+        deploymentName: z.ZodString;
+        buildId: z.ZodString;
+        artifactDigest: z.ZodString;
+        runtimeName: z.ZodString;
+        runtimeVersion: z.ZodString;
+        sdkVersion: z.ZodString;
+        manifestVersion: z.ZodNumber;
+        protocolVersion: z.ZodNumber;
+        manifestDigest: z.ZodString;
+        workflows: z.ZodRecord<z.ZodString, z.ZodObject<{
+            workflowVersion: z.ZodString;
+            workflowRevision: z.ZodString;
+            contractHash: z.ZodString;
+            activities: z.ZodRecord<z.ZodString, z.ZodObject<{
+                contractHash: z.ZodString;
+                implementationRevision: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+declare const getWorkerDiagnosticsInput: z.ZodObject<{
+    workerId: z.ZodString;
+}, z.core.$strip>;
+declare const getWorkerDiagnosticsOutput: z.ZodObject<{
+    worker: z.ZodNullable<z.ZodObject<{
+        instance: z.ZodObject<{
+            workerId: z.ZodString;
+            queue: z.ZodString;
+            health: z.ZodType<WorkerHealth, unknown, z.core.$ZodTypeInternals<WorkerHealth, unknown>>;
+            connectedAt: z.ZodNumber;
+            startedAt: z.ZodNumber;
+            lastHeartbeatAt: z.ZodNumber;
+            heartbeatAgeMs: z.ZodNumber;
+        }, z.core.$strict>;
+        deploymentVersion: z.ZodObject<{
+            deploymentName: z.ZodString;
+            buildId: z.ZodString;
+            artifactDigest: z.ZodString;
+            runtimeName: z.ZodString;
+            runtimeVersion: z.ZodString;
+            sdkVersion: z.ZodString;
+            manifestVersion: z.ZodNumber;
+            protocolVersion: z.ZodNumber;
+            manifestDigest: z.ZodString;
+            workflows: z.ZodRecord<z.ZodString, z.ZodObject<{
+                workflowVersion: z.ZodString;
+                workflowRevision: z.ZodString;
+                contractHash: z.ZodString;
+                activities: z.ZodRecord<z.ZodString, z.ZodObject<{
+                    contractHash: z.ZodString;
+                    implementationRevision: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+}, z.core.$strip>;
+export type GetWorkerDiagnosticsInput = z.infer<typeof getWorkerDiagnosticsInput>;
+export type WorkerDiagnosticsEntry = z.infer<typeof workerDiagnosticsEntrySchema>;
+export type GetWorkerDiagnosticsOutput = z.infer<typeof getWorkerDiagnosticsOutput>;
+type GetWorkerDiagnosticsOptions = {
+    workerRegistry?: WorkerRegistry;
+    clock?: () => number;
+};
+/**
+ * Build the `weft.workers.diagnostics` operation, optionally bound to a live
+ * `WorkerRegistry` and clock. Mirrors `createListWorkersOperation`'s
+ * discovery-only fallback: when `workerRegistry` is omitted, `invoke` throws
+ * if reached — reserved for discovery-only registries (OpenAPI/AsyncAPI).
+ */
+export declare function createGetWorkerDiagnosticsOperation(options?: GetWorkerDiagnosticsOptions): import("../operation-catalog.ts").OperationDefinition<{
+    workerId: string;
+}, {
+    worker: {
+        instance: {
+            workerId: string;
+            queue: string;
+            health: WorkerHealth;
+            connectedAt: number;
+            startedAt: number;
+            lastHeartbeatAt: number;
+            heartbeatAgeMs: number;
+        };
+        deploymentVersion: {
+            deploymentName: string;
+            buildId: string;
+            artifactDigest: string;
+            runtimeName: string;
+            runtimeVersion: string;
+            sdkVersion: string;
+            manifestVersion: number;
+            protocolVersion: number;
+            manifestDigest: string;
+            workflows: Record<string, {
+                workflowVersion: string;
+                workflowRevision: string;
+                contractHash: string;
+                activities: Record<string, {
+                    contractHash: string;
+                    implementationRevision: string;
+                }>;
+            }>;
+        };
+    } | null;
+}, unknown>;
+/** Default discovery-only operation; live servers use `createGetWorkerDiagnosticsOperation(...)`. */
+export declare const getWorkerDiagnosticsOperation: import("../operation-catalog.ts").OperationDefinition<{
+    workerId: string;
+}, {
+    worker: {
+        instance: {
+            workerId: string;
+            queue: string;
+            health: WorkerHealth;
+            connectedAt: number;
+            startedAt: number;
+            lastHeartbeatAt: number;
+            heartbeatAgeMs: number;
+        };
+        deploymentVersion: {
+            deploymentName: string;
+            buildId: string;
+            artifactDigest: string;
+            runtimeName: string;
+            runtimeVersion: string;
+            sdkVersion: string;
+            manifestVersion: number;
+            protocolVersion: number;
+            manifestDigest: string;
+            workflows: Record<string, {
+                workflowVersion: string;
+                workflowRevision: string;
+                contractHash: string;
+                activities: Record<string, {
+                    contractHash: string;
+                    implementationRevision: string;
+                }>;
+            }>;
+        };
+    } | null;
+}, unknown>;
+/**
+ * Build the REST binding for `weft.workers.diagnostics`. The binding is
+ * metadata only; the live `WorkerRegistry` is wired into the operation.
+ */
+export declare function createGetWorkerDiagnosticsRestBinding(): UnknownRestBinding;
+export {};

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

@@ -0,0 +1,117 @@
+import { z } from "zod";
+import { shapeOperationFaultAsJson } from "../operation-fault.js";
+import { defineOperation } from "../operation-registry.js";
+const workerHealthSchema = z.enum(["active", "draining", "drained"]), workerActivityContractSchema = z.object({
+  contractHash: z.string(),
+  implementationRevision: z.string()
+}).strict(), workerWorkflowContractSummarySchema = z.object({
+  workflowVersion: z.string(),
+  workflowRevision: z.string(),
+  contractHash: z.string(),
+  activities: z.record(z.string(), workerActivityContractSchema)
+}).strict(), workerInstanceIdentitySchema = z.object({
+  workerId: z.string(),
+  queue: z.string(),
+  health: workerHealthSchema,
+  connectedAt: z.number(),
+  startedAt: z.number(),
+  lastHeartbeatAt: z.number(),
+  heartbeatAgeMs: z.number()
+}).strict(), workerDeploymentVersionIdentitySchema = z.object({
+  deploymentName: z.string(),
+  buildId: z.string(),
+  artifactDigest: z.string(),
+  runtimeName: z.string(),
+  runtimeVersion: z.string(),
+  sdkVersion: z.string(),
+  manifestVersion: z.number(),
+  protocolVersion: z.number(),
+  manifestDigest: z.string(),
+  workflows: z.record(z.string(), workerWorkflowContractSummarySchema)
+}).strict(), workerDiagnosticsEntrySchema = z.object({
+  instance: workerInstanceIdentitySchema,
+  deploymentVersion: workerDeploymentVersionIdentitySchema
+}).strict(), getWorkerDiagnosticsInput = z.object({
+  workerId: z.string().min(1)
+}), getWorkerDiagnosticsOutput = z.object({
+  worker: workerDiagnosticsEntrySchema.nullable()
+});
+function projectWorkerDiagnostics(registry, workerId, now) {
+  const worker = registry.getWorker(workerId);
+  if (worker === void 0)
+    return null;
+  const summary = registry.getWorkerSummaries(now).find((entry) => entry.id === workerId);
+  if (summary === void 0)
+    return null;
+  const workflows = {};
+  for (const [workflowType, contract] of Object.entries(worker.manifest.workflows))
+    workflows[workflowType] = {
+      workflowVersion: contract.workflowVersion,
+      workflowRevision: contract.workflowRevision,
+      contractHash: contract.contractHash,
+      activities: { ...contract.activities }
+    };
+  return {
+    instance: {
+      workerId: worker.id,
+      queue: worker.queue,
+      health: summary.health,
+      connectedAt: worker.connectedAt,
+      startedAt: worker.startedAt,
+      lastHeartbeatAt: worker.lastHeartbeat,
+      heartbeatAgeMs: summary.heartbeatAgeMs
+    },
+    deploymentVersion: {
+      deploymentName: worker.manifest.deployment.name,
+      buildId: worker.manifest.deployment.buildId,
+      artifactDigest: worker.manifest.deployment.artifactDigest,
+      runtimeName: worker.manifest.runtime.name,
+      runtimeVersion: worker.manifest.runtime.version,
+      sdkVersion: worker.manifest.sdkVersion,
+      manifestVersion: worker.manifest.manifestVersion,
+      protocolVersion: worker.manifest.protocolVersion,
+      manifestDigest: worker.acceptedManifestDigest,
+      workflows
+    }
+  };
+}
+export function createGetWorkerDiagnosticsOperation(options = {}) {
+  const registry = options.workerRegistry, clock = options.clock ?? Date.now;
+  return defineOperation({
+    name: "weft.workers.diagnostics",
+    mcpExposable: !1,
+    summary: "Get bounded instance and deployment-version diagnostics for one connected worker",
+    description: "Report one connected worker's identity split into two parts: `instance` (this live " + "connection \u2014 queue, health, connection timestamps) and `deploymentVersion` (the " + "artifact it loaded \u2014 SDK/runtime identity, manifest digest, and every advertised " + "workflow's version, revision, and contract hash). Returns `worker: null` when the workerId is not currently connected. Excludes capabilities and raw payload schemas.",
+    destructive: !1,
+    tags: ["Observability"],
+    inputSchema: getWorkerDiagnosticsInput,
+    outputSchema: getWorkerDiagnosticsOutput,
+    access: { kind: "scoped", scopes: { kind: "anyOf", scopes: ["system:read"] } },
+    producibleFaults: [],
+    discoverable: !0,
+    transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+    unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+    invoke: async ({ input }) => {
+      if (registry === void 0)
+        throw Error("weft.workers.diagnostics invoked from a discovery-only operation registry; no WorkerRegistry was wired in");
+      return { worker: projectWorkerDiagnostics(registry, input.workerId, clock()) };
+    }
+  });
+}
+export const getWorkerDiagnosticsOperation = createGetWorkerDiagnosticsOperation();
+export function createGetWorkerDiagnosticsRestBinding() {
+  return {
+    method: "GET",
+    path: "/v1/workers/:workerId/diagnostics",
+    pathParamNames: ["workerId"],
+    operationName: "weft.workers.diagnostics",
+    inputSources: {
+      workerId: { kind: "path", pathParam: "workerId" }
+    },
+    extractInput: async (_request, pathParams) => ({
+      workerId: pathParams.workerId ?? ""
+    }),
+    success: { kind: "json", status: 200 },
+    shapeFault: shapeOperationFaultAsJson
+  };
+}

package/dist/server/operations/list-worker-registration-rejections.d.ts

@@ -0,0 +1,79 @@
+/**
+ * `weft.workers.rejections` operation + REST binding.
+ *
+ * Bounded, auditable log of recently declined `register` attempts (WFT-29):
+ * the rejection code, the attempted workerId when known, and whatever
+ * deployment/queue identity had already been parsed by the time the gate
+ * that rejected it ran. No free-text rejection message and no manifest
+ * content — this surfaces "who got rejected, when, and why (by code)", not
+ * a diagnostic dump.
+ *
+ * @module server/operations/list-worker-registration-rejections
+ */
+import { z } from 'zod';
+import type { WorkerRegistry } from '../../worker/registry.ts';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const listWorkerRegistrationRejectionsInput: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+declare const listWorkerRegistrationRejectionsOutput: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        code: z.ZodEnum<{
+            invalid_registration: "invalid_registration";
+            unsupported_protocol_version: "unsupported_protocol_version";
+            deployment_conflict: "deployment_conflict";
+            registration_rejected: "registration_rejected";
+        }>;
+        workerId: z.ZodOptional<z.ZodString>;
+        rejectedAt: z.ZodNumber;
+        queue: z.ZodOptional<z.ZodString>;
+        deploymentName: z.ZodOptional<z.ZodString>;
+        buildId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    limit: z.ZodNumber;
+}, z.core.$strip>;
+export type ListWorkerRegistrationRejectionsInput = z.infer<typeof listWorkerRegistrationRejectionsInput>;
+export type ListWorkerRegistrationRejectionsOutput = z.infer<typeof listWorkerRegistrationRejectionsOutput>;
+type ListWorkerRegistrationRejectionsOptions = {
+    workerRegistry?: WorkerRegistry;
+};
+/**
+ * Build the `weft.workers.rejections` operation, optionally bound to a live
+ * `WorkerRegistry`. Mirrors `createListWorkersOperation`'s discovery-only
+ * fallback: when `workerRegistry` is omitted, `invoke` throws if reached —
+ * reserved for discovery-only registries (OpenAPI/AsyncAPI).
+ */
+export declare function createListWorkerRegistrationRejectionsOperation(options?: ListWorkerRegistrationRejectionsOptions): import("../operation-catalog.ts").OperationDefinition<{
+    limit: number;
+}, {
+    items: {
+        code: "invalid_registration" | "unsupported_protocol_version" | "deployment_conflict" | "registration_rejected";
+        rejectedAt: number;
+        workerId?: string | undefined;
+        queue?: string | undefined;
+        deploymentName?: string | undefined;
+        buildId?: string | undefined;
+    }[];
+    limit: number;
+}, unknown>;
+/** Default discovery-only operation; live servers use `createListWorkerRegistrationRejectionsOperation(...)`. */
+export declare const listWorkerRegistrationRejectionsOperation: import("../operation-catalog.ts").OperationDefinition<{
+    limit: number;
+}, {
+    items: {
+        code: "invalid_registration" | "unsupported_protocol_version" | "deployment_conflict" | "registration_rejected";
+        rejectedAt: number;
+        workerId?: string | undefined;
+        queue?: string | undefined;
+        deploymentName?: string | undefined;
+        buildId?: string | undefined;
+    }[];
+    limit: number;
+}, unknown>;
+/**
+ * Build the REST binding for `weft.workers.rejections`. The
+ * binding is metadata only; the live `WorkerRegistry` is wired into the
+ * operation, not the binding.
+ */
+export declare function createListWorkerRegistrationRejectionsRestBinding(): UnknownRestBinding;
+export {};