@desplega.ai/agent-swarm 2.4.0 → 2.4.2

package/src/tools/app-rows.ts

@@ -0,0 +1,239 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z from "zod";
+import { AppNameSchema, type ModelDef, SYSTEM_COLUMN_KINDS } from "../apps/definition";
+import {
+  type AppRow,
+  AppRowAppNotFoundError,
+  AppRowValidationError,
+  createAppRow,
+  createAppRows,
+  deleteAppRow,
+  getAppRow,
+  patchAppRow,
+  validValue,
+} from "../apps/row-store";
+import { appDefinitionNeedsRepair, getApp } from "../apps/store";
+import { getAgentById } from "../be/db";
+import {
+  MAX_APP_BULK_ROWS_BODY_BYTES,
+  MAX_APP_ROW_BODY_BYTES,
+  rowMatchesFilters,
+  selectAppRows,
+} from "../http/apps";
+import { can } from "../rbac";
+import {
+  createToolRegistrar,
+  type SwarmToolResult,
+  swarmToolOutputSchema,
+  toolErr,
+  toolOk,
+} from "./utils";
+
+const base = { appId: z.string().min(1), model: AppNameSchema };
+const rowId = z.string().min(1);
+const values = z.record(z.string(), z.unknown());
+const equals = z.record(z.string(), z.union([z.string(), z.number(), z.boolean()]));
+const limit = z.number().int().min(1).max(1000);
+const rowOutput = { row: z.looseObject({}).optional() };
+const rowsOutput = { rows: z.array(z.looseObject({})).optional() };
+
+function checkSize(value: unknown, max: number): void {
+  if (Buffer.byteLength(JSON.stringify(value), "utf8") > max) {
+    throw new AppRowValidationError([
+      { path: "values", message: `Row input exceeds ${max} bytes.` },
+    ]);
+  }
+}
+
+function rowFilters(model: ModelDef, equals: Record<string, string | number | boolean> = {}) {
+  return Object.entries(equals).map(([column, value]) => {
+    const declared = Object.hasOwn(model.columns, column) ? model.columns[column] : undefined;
+    if ((!declared && !Object.hasOwn(SYSTEM_COLUMN_KINDS, column)) || declared?.hidden) {
+      throw new AppRowValidationError([
+        { path: `equals.${column}`, message: "Unknown or hidden column." },
+      ]);
+    }
+    if (declared?.kind === "json") {
+      throw new AppRowValidationError([
+        { path: `equals.${column}`, message: "json columns cannot be filtered" },
+      ]);
+    }
+    if (!validValue(declared ?? { kind: SYSTEM_COLUMN_KINDS[column]! }, value)) {
+      throw new AppRowValidationError([
+        { path: `equals.${column}`, message: "Filter value must match the column kind." },
+      ]);
+    }
+    return { column, value };
+  });
+}
+
+export function registerAppRowTools(server: McpServer) {
+  function register<Shape extends z.ZodRawShape>(
+    name: string,
+    description: string,
+    shape: Shape,
+    output: z.ZodRawShape,
+    operation: (
+      args: z.infer<z.ZodObject<typeof base & Shape>>,
+      model: ModelDef,
+      actor: string,
+    ) => Promise<SwarmToolResult>,
+    readOnly = false,
+  ) {
+    createToolRegistrar(server)(
+      name,
+      {
+        title: description,
+        description,
+        annotations: { readOnlyHint: readOnly },
+        rbac: { permission: "app.use" },
+        inputSchema: z.object({ ...base, ...shape }),
+        outputSchema: swarmToolOutputSchema(output),
+      },
+      async (args, info) => {
+        if (!info.agentId) return toolErr('Agent ID not found. Set the "X-Agent-ID" header.');
+        const { appId, model: modelName } = z.object(base).parse(args);
+        const agent = await getAgentById(info.agentId);
+        const decision = can({
+          principal: { kind: "agent", agentId: info.agentId, isLead: agent?.isLead ?? false },
+          verb: "app.use",
+          resource: { kind: "app", appId },
+          source: "mcp",
+        });
+        if (!decision.allow) return toolErr(decision.reason);
+        const app = await getApp(appId);
+        if (!app) return toolErr("App not found.");
+        if (appDefinitionNeedsRepair(app))
+          return toolErr("App definition needs repair.", { data: { issues: app.definitionError } });
+        if (!Object.hasOwn(app.definition.models, modelName)) return toolErr("Model not found.");
+        try {
+          return await operation(args, app.definition.models[modelName]!, `agent:${info.agentId}`);
+        } catch (error) {
+          if (error instanceof AppRowValidationError)
+            return toolErr(error.message, { data: { issues: error.issues } });
+          if (error instanceof AppRowAppNotFoundError) return toolErr(error.message);
+          throw error;
+        }
+      },
+    );
+  }
+
+  register(
+    "app-rows-list",
+    "List app rows with equality filters, sorting, and a limit.",
+    {
+      equals: equals.optional(),
+      sort: z.string().optional(),
+      limit: limit.optional(),
+    },
+    { ...rowsOutput, total: z.number().optional() },
+    async (args, model) => {
+      const data = await selectAppRows(
+        args.appId,
+        args.model,
+        model,
+        rowFilters(model, args.equals),
+        args.sort,
+        args.limit,
+        true,
+      );
+      return toolOk(`Found ${data.total} row(s).`, { data });
+    },
+    true,
+  );
+
+  register(
+    "app-row-get",
+    "Get an app row.",
+    { rowId },
+    rowOutput,
+    async (args) => {
+      const row = await getAppRow(args.appId, args.model, args.rowId);
+      return row ? toolOk("Row retrieved.", { data: { row } }) : toolErr("Row not found.");
+    },
+    true,
+  );
+
+  register(
+    "app-row-create",
+    "Create an app row.",
+    { values },
+    rowOutput,
+    async (args, model, actor) => {
+      checkSize({ values: args.values }, MAX_APP_ROW_BODY_BYTES);
+      const row = await createAppRow(args.appId, args.model, model, args.values, { actor });
+      return toolOk("Row created.", { data: { row } });
+    },
+  );
+
+  register(
+    "app-rows-create",
+    "Create up to 500 app rows within 10 MiB.",
+    {
+      rows: z.array(values).min(1).max(500),
+    },
+    rowsOutput,
+    async (args, model, actor) => {
+      checkSize({ rows: args.rows }, MAX_APP_BULK_ROWS_BODY_BYTES);
+      for (const values of args.rows) checkSize({ values }, MAX_APP_ROW_BODY_BYTES);
+      const rows = await createAppRows(args.appId, args.model, model, args.rows, { actor });
+      return toolOk(`Created ${rows.length} row(s).`, { data: { rows } });
+    },
+  );
+
+  register(
+    "app-row-patch",
+    "Patch an app row.",
+    { rowId, values },
+    rowOutput,
+    async (args, model, actor) => {
+      checkSize({ values: args.values }, MAX_APP_ROW_BODY_BYTES);
+      const row = await patchAppRow(args.appId, args.model, model, args.rowId, args.values, {
+        actor,
+      });
+      return row ? toolOk("Row updated.", { data: { row } }) : toolErr("Row not found.");
+    },
+  );
+
+  register(
+    "app-row-delete",
+    "Delete an app row.",
+    { rowId },
+    { ok: z.boolean().optional() },
+    async (args, model) => {
+      const deleted = await deleteAppRow(args.appId, args.model, model, args.rowId);
+      return deleted ? toolOk("Row deleted.", { data: { ok: true } }) : toolErr("Row not found.");
+    },
+  );
+
+  register(
+    "app-rows-delete",
+    "Delete matching app rows. Supply at least one equality filter.",
+    {
+      equals: equals.refine(
+        (value) => Object.keys(value).length > 0,
+        "Supply at least one equality filter.",
+      ),
+      limit: limit.optional(),
+    },
+    { deleted: z.number().optional() },
+    async (args, model) => {
+      const filters = rowFilters(model, args.equals);
+      const { rows } = await selectAppRows(
+        args.appId,
+        args.model,
+        model,
+        filters,
+        undefined,
+        args.limit ?? 1000,
+        true,
+      );
+      // Re-check under the row lock: a row patched out of the filter since the select is kept.
+      const matches = (row: AppRow) => rowMatchesFilters(row, filters);
+      let deleted = 0;
+      for (const row of rows)
+        if (await deleteAppRow(args.appId, args.model, model, row.id, matches)) deleted++;
+      return toolOk(`Deleted ${deleted} row(s).`, { data: { deleted } });
+    },
+  );
+}

package/src/tools/model-catalog/index.ts

@@ -87,7 +87,7 @@ export const registerModelCatalogOverlayUpsertTool = (server: McpServer) => {
           .string()
           .min(1)
           .describe(
-            `models.dev provider id: anthropic, openai, openrouter, amazon-bedrock, opencode, ${openAICompatibleProviderIds().join(", ")}.`,
+            `models.dev provider id: anthropic, openai, openrouter, amazon-bedrock, opencode, opencode-go, ${openAICompatibleProviderIds().join(", ")}.`,
           ),
         modelId: z
           .string()

package/src/tools/tool-config.ts

@@ -189,6 +189,14 @@ export const DEFERRED_TOOLS = new Set([
   "app-list",
   "app-patch",
   "app-query",
+  "app-rows-list",
+  "app-row-get",
+  "app-row-create",
+  "app-rows-create",
+  "app-row-patch",
+  "app-row-delete",
+  "app-rows-delete",
+  "app-action-run",
   "app-sync",
   "app-upsert",
   "app-history",

package/src/tools/utils.ts

@@ -347,7 +347,7 @@ export const NUDGES: Record<string, (result: SwarmToolResult) => string | undefi
     const hasQueries = Object.keys(definition?.queries ?? {}).length > 0;
     const hasActions = Object.keys(definition?.actions ?? {}).length > 0;
     return hasQueries || hasActions
-      ? "This app's callable surface is `definition.queries` (run with `app-query`, passing any `$param` values) and `definition.actions` (invoke with `POST /api/apps/<id>/actions/<name>`; `sync` actions refresh sources)."
+      ? "Run `definition.queries` with `app-query` and supply each `$param` value. Invoke `definition.actions` with `app-action-run` through MCP or `POST /api/apps/<id>/actions/<name>` through REST. Sync actions refresh sources."
       : undefined;
   },
   // kv-get is spill-exempt (retrieval path), so oversized values reach the

package/src/tools/workflows/retry-workflow-run.ts

@@ -10,7 +10,7 @@ export const registerRetryWorkflowRunTool = (server: McpServer) => {
       title: "Retry Workflow Run",
       annotations: { destructiveHint: false },
       description:
-        "Retry a failed workflow run from the beginning. The run must be in 'failed' status.",
+        "Resume the same failed workflow run from its failed step(s); completed steps are not re-run. Retrying re-creates the failed node's side effects (e.g. an agent task), so check the target state first if that work was already done manually.",
       inputSchema: z.object({
         runId: z.string().uuid().describe("Workflow run ID to retry"),
       }),

package/src/types.ts

@@ -1362,6 +1362,14 @@ export const AgentBedrockStatusSchema = z
   .openapi("AgentBedrockStatus");
 export type AgentBedrockStatus = z.infer<typeof AgentBedrockStatusSchema>;
 
+export const AgentOpencodeGoStatusSchema = z
+  .object({
+    probedAt: z.number(), // unix ms
+    models: z.array(z.string()).default([]),
+  })
+  .openapi("AgentOpencodeGoStatus");
+export type AgentOpencodeGoStatus = z.infer<typeof AgentOpencodeGoStatusSchema>;
+
 const AcpSessionConfigSelectValueSchema = z.object({
   value: z.string(),
   name: z.string(),
@@ -1421,6 +1429,8 @@ export const AgentCredStatusSchema = z
     reportKind: z.enum(["boot", "post_task"]).default("boot"),
     /** Pi-mono Bedrock enumeration block — null when not in Bedrock mode. */
     bedrock: AgentBedrockStatusSchema.nullable().default(null),
+    /** Pi-mono only: the `opencode-go` model ids the worker's pi-ai resolves. */
+    opencodeGo: AgentOpencodeGoStatusSchema.nullable().default(null),
     /** ACP options advertised by the most recently created session. */
     acp: AgentAcpStatusSchema.nullable().default(null),
   })
@@ -2210,6 +2220,13 @@ export const RetryPolicySchema = z
   .openapi("RetryPolicy");
 export type RetryPolicy = z.infer<typeof RetryPolicySchema>;
 
+/**
+ * `failureReason` of a workflow-step task cut by a supersede (deploy drain,
+ * heartbeat remediation). The workflow engine re-dispatches it once even
+ * when the node declares no `retry` (see `scheduleTaskStepRetry`).
+ */
+export const SUPERSEDED_WORKFLOW_TASK_REASON = "superseded_workflow_task";
+
 // --- Executor Metadata ---
 
 export const ExecutorMetaSchema = z

package/src/utils/company-profile.ts

@@ -0,0 +1,24 @@
+export const COMPANY_TEAM_SIZES = ["1", "2-10", "11-50", "51+"] as const;
+
+export const COMPANY_USE_CASES = ["features", "bugs", "review", "ops", "docs", "data"] as const;
+
+export const COMPANY_ACQUISITION_SOURCES = [
+  "search",
+  "github",
+  "social",
+  "colleague",
+  "newsletter",
+  "event",
+  "ai_assistant",
+  "hacker_news",
+  "other",
+] as const;
+
+export const USER_FUNCTIONS = [
+  "engineer",
+  "eng_lead",
+  "founder",
+  "product",
+  "ops",
+  "other",
+] as const;

package/src/utils/org-website.ts

@@ -71,34 +71,71 @@ export function isFilledOrgLogoUrl(
   }
 }
 
+/**
+ * Free-mail providers with regional domains, matched on the label before the
+ * public suffix: hotmail.es, yahoo.co.uk, gmx.net and yandex.com.tr all count.
+ */
+const FREE_MAIL_FAMILIES = new Set([
+  "aol",
+  "fastmail",
+  "gmail",
+  "gmx",
+  "googlemail",
+  "hotmail",
+  "icloud",
+  "live",
+  "msn",
+  "outlook",
+  "protonmail",
+  "rocketmail",
+  "yahoo",
+  "yandex",
+  "ymail",
+  "zoho",
+]);
+
+/** Free-mail providers on one domain only, where the label alone is too generic. */
 const FREE_MAIL_DOMAINS = new Set([
-  "gmail.com",
-  "googlemail.com",
-  "outlook.com",
-  "hotmail.com",
-  "live.com",
-  "msn.com",
-  "yahoo.com",
-  "icloud.com",
-  "me.com",
+  "126.com",
+  "163.com",
+  "comcast.net",
+  "daum.net",
+  "free.fr",
+  "hanmail.net",
+  "hey.com",
+  "libero.it",
   "mac.com",
-  "aol.com",
-  "proton.me",
-  "protonmail.com",
-  "gmx.com",
-  "gmx.de",
-  "yandex.com",
-  "yandex.ru",
   "mail.com",
-  "zoho.com",
+  "mail.ru",
+  "me.com",
+  "naver.com",
+  "orange.fr",
+  "pm.me",
+  "proton.me",
   "qq.com",
-  "163.com",
-  "hey.com",
-  "fastmail.com",
+  "rediffmail.com",
+  "sina.com",
+  "t-online.de",
+  "tutanota.com",
+  "web.de",
 ]);
 
+/** Second-level labels of a country code suffix (acme.co.uk, acme.com.br). */
+const SECOND_LEVEL_LABELS = new Set(["ac", "co", "com", "edu", "gov", "ne", "net", "or", "org"]);
+
+/** Whether `host` (a normalized hostname) belongs to a public free-mail provider. */
+function isFreeMailHost(host: string): boolean {
+  const labels = host.split(".");
+  const suffixLength = labels.length > 2 && SECOND_LEVEL_LABELS.has(labels.at(-2) ?? "") ? 2 : 1;
+  // mail.yahoo.co.uk becomes yahoo.co.uk.
+  const registrable = labels.slice(-(suffixLength + 1));
+  return (
+    FREE_MAIL_FAMILIES.has(registrable[0] ?? "") || FREE_MAIL_DOMAINS.has(registrable.join("."))
+  );
+}
+
 /** The admin's email domain as a website suggestion, or null for free-mail domains. */
 export function websiteSuggestion(orgDomain: string | null | undefined): string | null {
   const host = normalizeOrgWebsite(orgDomain);
-  return host && !FREE_MAIL_DOMAINS.has(host) ? host : null;
+  return host && !isFreeMailHost(host) ? host : null;
 }

package/src/workflows/recovery.ts

@@ -25,7 +25,12 @@ import {
 } from "./engine";
 import type { ExecutorRegistry } from "./executors/registry";
 import { getSecretInputKeys } from "./input";
-import { finalizeOrWait, resumeFromChildRun, resumeWaitState } from "./resume";
+import {
+  finalizeOrWait,
+  recoverResolvedWaitState,
+  resumeFromChildRun,
+  resumeWaitState,
+} from "./resume";
 import {
   checkpointPortStepAndResolveSuccessors,
   completeTaskStepAndResolveSuccessors,
@@ -392,21 +397,12 @@ async function recoverWaitStates(registry: ExecutorRegistry): Promise<number> {
 
   for (const stuck of stuckRuns) {
     try {
-      // Decide what status to (re)apply.
-      let resumeStatus: "fired" | "timeout";
-      let payload: unknown;
-
-      if (stuck.waitStatus === "fired") {
-        resumeStatus = "fired";
-        payload = stuck.firedPayload != null ? safeJsonParse(stuck.firedPayload) : undefined;
-      } else if (stuck.waitStatus === "timeout") {
-        resumeStatus = "timeout";
+      if (stuck.waitStatus === "pending") {
+        const status = stuck.waitMode === "time" ? "fired" : "timeout";
+        await resumeWaitState(stuck.waitId, status, undefined, registry);
       } else {
-        // pending + overdue
-        resumeStatus = stuck.waitMode === "time" ? "fired" : "timeout";
+        await recoverResolvedWaitState(stuck.waitId, registry);
       }
-
-      await resumeWaitState(stuck.waitId, resumeStatus, payload, registry);
       recovered++;
     } catch (err) {
       if (await failRunOnUnreadableReplay(stuck.runId, err)) continue;
@@ -417,14 +413,6 @@ async function recoverWaitStates(registry: ExecutorRegistry): Promise<number> {
   return recovered;
 }
 
-function safeJsonParse(s: string): unknown {
-  try {
-    return JSON.parse(s);
-  } catch {
-    return s;
-  }
-}
-
 /**
  * Get run IDs by status. Simple query since there's no dedicated function for this.
  */

package/src/workflows/resume.ts

@@ -711,6 +711,22 @@ export async function resumeWaitState(
   );
 }
 
+/** Finish a wait resolution that committed before its step was checkpointed. */
+export async function recoverResolvedWaitState(
+  waitId: string,
+  registry: ExecutorRegistry,
+): Promise<void> {
+  const waitRow = await getWaitStateById(waitId);
+  if (!waitRow) return;
+  const status = waitRow.status;
+  if (status !== "fired" && status !== "timeout") return;
+
+  // Replay the durable result; the step checkpoint arbitrates concurrent resumes.
+  await failClosedOnUnreadableReplay(waitRow.workflowRunId, waitRow.workflowRunStepId, () =>
+    resumeClaimedWait(waitRow, status, waitRow.firedPayload, registry),
+  );
+}
+
 async function resumeClaimedWait(
   waitRow: WaitStateRow,
   status: "fired" | "timeout",

package/src/workflows/task-step-routing.ts

@@ -2,12 +2,15 @@ import {
   detachTaskFromWorkflowRunStep,
   getDbClient,
   getTaskById,
+  getWorkflowRun,
   getWorkflowRunStep,
   updateWorkflowRun,
   updateWorkflowRunStep,
 } from "../be/db";
 import {
+  type RetryPolicy,
   RetryPolicySchema,
+  SUPERSEDED_WORKFLOW_TASK_REASON,
   type WorkflowDefinition,
   type WorkflowNode,
   type WorkflowRunStep,
@@ -17,7 +20,7 @@ import { getSuccessors } from "./definition";
 import { joinForeach, resolveForeachParent } from "./foreach-join";
 
 export interface PortStepRoutingResult {
-  /** False when another handler already moved the step out of `waiting`. */
+  /** False when the step was already claimed or its run is terminal. */
   claimed: boolean;
   successors: WorkflowNode[];
 }
@@ -85,6 +88,10 @@ export async function checkpointPortStepAndResolveSuccessors(
   return await getDbClient().transaction(async (): Promise<PortStepRoutingResult> => {
     const current = await getWorkflowRunStep(stepId);
     if (!current || current.status !== "waiting") return { claimed: false, successors: [] };
+    const run = await getWorkflowRun(runId);
+    if (!run || (run.status !== "waiting" && run.status !== "running")) {
+      return { claimed: false, successors: [] };
+    }
     await checkpointStep(runId, stepId, nodeId, { output, nextPort }, ctx);
     await updateWorkflowRun(runId, { status: "running" });
     return { claimed: true, successors: getSuccessors(def, nodeId, nextPort) };
@@ -97,15 +104,33 @@ export async function checkpointPortStepAndResolveSuccessors(
  * - `not-claimed`: another handler already moved the step out of `waiting`,
  *   or the failed task is no longer the one bound to the step (it was
  *   already retried and a fresh task now owns it); the caller stops.
- * - `not-eligible`: no retry applies (no `node.retry`, not an agent-task node,
- *   or retries exhausted); the caller applies `onNodeFailure` as before.
+ * - `not-eligible`: no retry applies (no `node.retry` and not a supersede
+ *   cut, not an agent-task node, or retries exhausted); the caller applies
+ *   `onNodeFailure` as before.
  */
 export type TaskStepRetryOutcome = "scheduled" | "not-claimed" | "not-eligible";
 
+/**
+ * Retry applied to an agent-task step whose task was cut by a supersede
+ * (deploy drain, heartbeat remediation) when the node declares no `retry`.
+ * The cut is not the task's fault, so the step gets one fresh attempt after
+ * the restart settles. An explicit `node.retry` always wins; `retry:
+ * { maxRetries: 0 }` opts a node with external side effects out.
+ */
+export const SUPERSEDE_RETRY_POLICY: RetryPolicy = {
+  maxRetries: 1,
+  strategy: "static",
+  baseDelayMs: 30_000,
+  maxDelayMs: 30_000,
+};
+
 /**
  * Apply a node's `retry` policy to a FAILED agent-task step task. The sync
  * executor path does this in `executeStep`; an async agent-task step only
  * learns about the failure here, from `task.failed` or the recovery sweep.
+ * A node without `retry` gets `SUPERSEDE_RETRY_POLICY` when the task was
+ * failed with `SUPERSEDED_WORKFLOW_TASK_REASON`. The task row is checked as
+ * well as `reason`, because the recovery sweep passes its own reason text.
  *
  * In one transaction: re-claim the step while it is still `waiting` AND still
  * bound to the failed task, detach that task (the executor reuses any task
@@ -114,6 +139,9 @@ export type TaskStepRetryOutcome = "scheduled" | "not-claimed" | "not-eligible";
  * task. Bounded by `maxRetries` via the step's persisted `retryCount`, read
  * only after ownership is confirmed: a stale caller's step snapshot may carry
  * the counter of a newer attempt.
+ *
+ * Foreach children (`<foreachId>#<key>`) are not matched here: the retry
+ * poller resolves nodes by exact id and cannot re-dispatch a child yet.
  */
 export async function scheduleTaskStepRetry(
   def: WorkflowDefinition,
@@ -123,10 +151,16 @@ export async function scheduleTaskStepRetry(
   reason: string,
 ): Promise<TaskStepRetryOutcome> {
   const node = def.nodes.find((n) => n.id === step.nodeId);
-  if (!node || node.type !== "agent-task" || !node.retry) return "not-eligible";
-  const parsed = RetryPolicySchema.safeParse(node.retry);
-  if (!parsed.success) return "not-eligible";
-  const policy = parsed.data;
+  if (!node || node.type !== "agent-task") return "not-eligible";
+  let policy: RetryPolicy;
+  if (node.retry) {
+    const parsed = RetryPolicySchema.safeParse(node.retry);
+    if (!parsed.success) return "not-eligible";
+    policy = parsed.data;
+  } else {
+    if (!(await isSupersedeCut(taskId, reason))) return "not-eligible";
+    policy = SUPERSEDE_RETRY_POLICY;
+  }
 
   return await getDbClient().transaction(async (): Promise<TaskStepRetryOutcome> => {
     const current = await getWorkflowRunStep(step.id);
@@ -139,6 +173,12 @@ export async function scheduleTaskStepRetry(
   });
 }
 
+async function isSupersedeCut(taskId: string, reason: string): Promise<boolean> {
+  if (reason === SUPERSEDED_WORKFLOW_TASK_REASON) return true;
+  const task = await getTaskById(taskId);
+  return task?.failureReason === SUPERSEDED_WORKFLOW_TASK_REASON;
+}
+
 export interface TaskStepRoutingResult {
   /**
    * False when another handler already moved the step out of `waiting` — the