@desplega.ai/agent-swarm 1.136.0 → 1.138.0

package/src/tests/workflow-swarm-script.test.ts

@@ -30,6 +30,9 @@ import {
   SwarmScriptExecutor,
 } from "../workflows/executors/swarm-script";
 import { interpolate } from "../workflows/template";
+import { SKIP_SANDBOX_SPAWN_TESTS } from "./sandbox-spawn-test-helpers";
+
+const skip = test.skipIf(SKIP_SANDBOX_SPAWN_TESTS);
 
 const TEST_DB_PATH = "./test-workflow-swarm-script.sqlite";
 const API_KEY = "test-workflow-swarm-script-key-1234567890";
@@ -185,7 +188,7 @@ describe("SwarmScriptExecutor", () => {
     ).toBe(SWARM_SCRIPT_MAX_TIMEOUT_MS);
   });
 
-  test("A workflow with one swarm-script node resolves by name + runs + returns result", async () => {
+  skip("A workflow with one swarm-script node resolves by name + runs + returns result", async () => {
     await saveScript(
       "scratch-add-one-a1b2c3d4",
       `export default async (args: { value: number }) => ({ value: args.value + 1 });`,
@@ -248,7 +251,7 @@ describe("SwarmScriptExecutor", () => {
     expect(result.output).toBeUndefined();
   });
 
-  test("named script source may contain literal mustache template data", async () => {
+  skip("named script source may contain literal mustache template data", async () => {
     await saveScript(
       "literal-mustache-source",
       `export default async () => ({ template: "Hello {{customer_name}}" });`,
@@ -272,7 +275,7 @@ describe("SwarmScriptExecutor", () => {
     expect(result.output?.result).toEqual({ template: "Hello {{customer_name}}" });
   });
 
-  test("unrelated upstream node names do not turn literal source templates into workflow tokens", async () => {
+  skip("unrelated upstream node names do not turn literal source templates into workflow tokens", async () => {
     await saveScript(
       "literal-upstream-name",
       `export default async () => ({ template: "Hello {{customer.name}}" });`,
@@ -325,7 +328,7 @@ describe("SwarmScriptExecutor", () => {
     expect(result.error).toContain("{{customer.name}}");
   });
 
-  test("swarm-script executor includes API connection descriptors in ctx.api", async () => {
+  skip("swarm-script executor includes API connection descriptors in ctx.api", async () => {
     await upsertScriptConnection({
       slug: "workflowVendor",
       kind: "openapi",
@@ -367,7 +370,7 @@ describe("SwarmScriptExecutor", () => {
     expect(result.output?.result).toEqual({ apiKeys: ["workflowVendor"] });
   });
 
-  test("pinHash correctly resolves to a historic script_versions row", async () => {
+  skip("pinHash correctly resolves to a historic script_versions row", async () => {
     const first = await saveScript("versioned", `export default async () => ({ version: "old" });`);
     await saveScript("versioned", `export default async () => ({ version: "new" });`);
 
@@ -391,7 +394,7 @@ describe("SwarmScriptExecutor", () => {
     expect(result.output?.version).toBe(1);
   });
 
-  test("inputs mapping from a predecessor node correctly populates args", async () => {
+  skip("inputs mapping from a predecessor node correctly populates args", async () => {
     await saveScript(
       "from-input",
       `export default async (args: { value: string }) => ({ seen: args.value });`,
@@ -439,7 +442,7 @@ describe("SwarmScriptExecutor", () => {
     expect(echoStep?.output).toEqual({ value: '{"a":1}' });
   });
 
-  test("{{path}} args: object arg is injected as raw object, not JSON string", async () => {
+  skip("{{path}} args: object arg is injected as raw object, not JSON string", async () => {
     await saveScript(
       "echo-obj",
       `export default async (args: { data: Record<string, unknown> }) => ({ isObject: typeof args.data === "object" && !Array.isArray(args.data), keys: Object.keys(args.data ?? {}) });`,
@@ -467,7 +470,7 @@ describe("SwarmScriptExecutor", () => {
     expect(scriptStep?.output).toMatchObject({ result: { isObject: true, keys: ["a", "b"] } });
   });
 
-  test("{{path}} args: array arg is injected as raw array, not JSON string", async () => {
+  skip("{{path}} args: array arg is injected as raw array, not JSON string", async () => {
     await saveScript(
       "echo-arr",
       `export default async (args: { items: string[] }) => ({ isArray: Array.isArray(args.items), length: args.items.length });`,
@@ -495,7 +498,7 @@ describe("SwarmScriptExecutor", () => {
     expect(scriptStep?.output).toMatchObject({ result: { isArray: true, length: 3 } });
   });
 
-  test("{{path}} args: empty array is injected as raw empty array with length 0, not '[]' string", async () => {
+  skip("{{path}} args: empty array is injected as raw empty array with length 0, not '[]' string", async () => {
     await saveScript(
       "echo-empty-arr",
       `export default async (args: { items: string[] }) => ({ isArray: Array.isArray(args.items), length: args.items.length });`,
@@ -523,7 +526,7 @@ describe("SwarmScriptExecutor", () => {
     expect(scriptStep?.output).toMatchObject({ result: { isArray: true, length: 0 } });
   });
 
-  test("{{path}} args: string scalar arg is injected as the string value", async () => {
+  skip("{{path}} args: string scalar arg is injected as the string value", async () => {
     await saveScript(
       "echo-str",
       `export default async (args: { name: string }) => ({ isString: typeof args.name === "string", value: args.name });`,
@@ -557,7 +560,7 @@ describe("SwarmScriptExecutor", () => {
     });
   });
 
-  test("{{path}} args: number scalar arg is injected as a number, not a string", async () => {
+  skip("{{path}} args: number scalar arg is injected as a number, not a string", async () => {
     await saveScript(
       "echo-num",
       `export default async (args: { count: number }) => ({ isNumber: typeof args.count === "number", value: args.count });`,
@@ -585,7 +588,7 @@ describe("SwarmScriptExecutor", () => {
     expect(scriptStep?.output).toMatchObject({ result: { isNumber: true, value: 3 } });
   });
 
-  test("{{path}} args: boolean scalar arg is injected as a boolean, not a string", async () => {
+  skip("{{path}} args: boolean scalar arg is injected as a boolean, not a string", async () => {
     await saveScript(
       "echo-bool",
       `export default async (args: { enabled: boolean }) => ({ isBoolean: typeof args.enabled === "boolean", value: args.enabled });`,
@@ -613,7 +616,7 @@ describe("SwarmScriptExecutor", () => {
     expect(scriptStep?.output).toMatchObject({ result: { isBoolean: true, value: false } });
   });
 
-  test("{{path}} args: mixed string template still produces a string via interpolation", async () => {
+  skip("{{path}} args: mixed string template still produces a string via interpolation", async () => {
     await saveScript(
       "echo-mixed",
       `export default async (args: { label: string }) => ({ isString: typeof args.label === "string", value: args.label });`,
@@ -643,7 +646,7 @@ describe("SwarmScriptExecutor", () => {
     });
   });
 
-  test("fsMode workspace-rw is rejected at config validation with a clear error message", async () => {
+  skip("fsMode workspace-rw is rejected at config validation with a clear error message", async () => {
     await saveScript("noop", `export default async () => ({ ok: true });`);
     const executor = new SwarmScriptExecutor(deps);
     const wf = await makeWorkflow({ nodes: [] });
@@ -676,7 +679,7 @@ describe("SwarmScriptExecutor", () => {
     expect(success.status).toBe("success");
   });
 
-  test("timeoutMs not set — script completes with the default 30s window", async () => {
+  skip("timeoutMs not set — script completes with the default 30s window", async () => {
     await saveScript("quick", `export default async () => ({ done: true });`);
     const executor = new SwarmScriptExecutor(deps);
     const wf = await makeWorkflow({ nodes: [] });
@@ -696,7 +699,7 @@ describe("SwarmScriptExecutor", () => {
     expect(result.output?.result).toEqual({ done: true });
   });
 
-  test("timeoutMs set — a long-running script is killed before it finishes", async () => {
+  skip("timeoutMs set — a long-running script is killed before it finishes", async () => {
     await saveScript(
       "sleeper",
       `export default async () => { await new Promise(r => setTimeout(r, 3000)); return { done: true }; };`,
@@ -719,7 +722,7 @@ describe("SwarmScriptExecutor", () => {
     expect(result.output?.exitCode).not.toBe(0);
   });
 
-  test("Failure in the script surfaces as a workflow-node failure", async () => {
+  skip("Failure in the script surfaces as a workflow-node failure", async () => {
     await saveScript("throws", `export default async () => { throw new Error("boom"); };`);
     const executor = new SwarmScriptExecutor(deps);
     const wf = await makeWorkflow({ nodes: [] });

package/src/tools/get-task-details.ts

@@ -40,6 +40,7 @@ const looseRoutingAffinitySchema = z.looseObject({
   role: z.string().optional(),
   harnessProvider: z.string().optional(),
   capabilities: z.array(z.string()).optional(),
+  leadOnly: z.boolean().optional(),
 });
 
 export const looseAgentTaskOutputSchema = z.looseObject({

package/src/tools/mcp-servers/mcp-server-create.ts

@@ -1,6 +1,11 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as z from "zod";
-import { createMcpServer, getAgentById, installMcpServer } from "@/be/db";
+import {
+  createMcpServer,
+  emitMcpServerConnectedTelemetry,
+  getAgentById,
+  installMcpServer,
+} from "@/be/db";
 import { can } from "@/rbac";
 import { createToolRegistrar, swarmToolOutputSchema, toolErr, toolOk } from "@/tools/utils";
 
@@ -102,6 +107,7 @@ export const registerMcpServerCreateTool = (server: McpServer) => {
           headerConfigKeys: args.headerConfigKeys,
           extraAuthorizeParams: args.extraAuthorizeParams,
         });
+        await emitMcpServerConnectedTelemetry();
 
         // Auto-install for the creating agent
         await installMcpServer(requestInfo.agentId, created.id);

package/src/tools/memory-search.ts

@@ -4,7 +4,11 @@ import { getAgentById } from "@/be/db";
 import { getEmbeddingProvider, getMemoryStore } from "@/be/memory";
 import { CANDIDATE_SET_MULTIPLIER } from "@/be/memory/constants";
 import { expandCandidatesWithGraph } from "@/be/memory/graph-expansion";
-import { recordRetrievals } from "@/be/memory/raters/retrieval";
+import {
+  dedupeMemoryDocumentIds,
+  recordMemoryAccesses,
+  recordRetrievals,
+} from "@/be/memory/raters/retrieval";
 import { rerank } from "@/be/memory/reranker";
 import { createToolRegistrar, swarmToolOutputSchema, toolErr, toolOk } from "@/tools/utils";
 import type { AgentMemorySource } from "@/types";
@@ -26,6 +30,7 @@ type MemorySearchResult = {
   retrievalSource?: string;
   tags?: string[];
   createdAt: string;
+  accessCount?: number;
   rateHint?: string;
 };
 
@@ -57,6 +62,7 @@ export const memorySearchOutputSchema = swarmToolOutputSchema({
         retrievalSource: z.enum(["vec", "fts", "hybrid", "fallback", "graph"]).optional(),
         tags: z.array(z.string()).optional(),
         createdAt: z.string().optional(),
+        accessCount: z.number().int().optional(),
         rateHint: z.string().optional(),
       }),
     )
@@ -70,7 +76,8 @@ export const registerMemorySearchTool = (server: McpServer) => {
       title: "Search memories",
       description:
         "Search your accumulated memories using natural language. Returns summaries with IDs — use memory-get to retrieve full content.",
-      annotations: { readOnlyHint: true },
+      // Search updates access telemetry for every logical document returned.
+      annotations: { readOnlyHint: false },
 
       inputSchema: z.object({
         query: z.string().min(1).describe("Natural language search query."),
@@ -148,6 +155,14 @@ export const registerMemorySearchTool = (server: McpServer) => {
           }
         }
 
+        const consumedIds = dedupeMemoryDocumentIds(ranked);
+        try {
+          await recordMemoryAccesses(consumedIds);
+        } catch (err) {
+          console.error("[memory-search] recordMemoryAccesses failed:", (err as Error).message);
+        }
+        const consumedIdSet = new Set(consumedIds);
+
         const inTaskContext = !!requestInfo.sourceTaskId;
         const mapped = ranked.map((r) => ({
           id: r.id,
@@ -159,6 +174,7 @@ export const registerMemorySearchTool = (server: McpServer) => {
           retrievalSource: r.retrievalSource,
           tags: r.tags,
           createdAt: r.createdAt,
+          accessCount: (r.accessCount ?? 0) + (consumedIdSet.has(r.id) ? 1 : 0),
           ...(inTaskContext && NUDGE_ELIGIBLE_SOURCES.has(r.source as AgentMemorySource)
             ? { rateHint: rateHintFor(r.id) }
             : {}),
@@ -180,6 +196,14 @@ export const registerMemorySearchTool = (server: McpServer) => {
         source,
       });
 
+      const consumedIds = dedupeMemoryDocumentIds(recent);
+      try {
+        await recordMemoryAccesses(consumedIds);
+      } catch (err) {
+        console.error("[memory-search] recordMemoryAccesses failed:", (err as Error).message);
+      }
+      const consumedIdSet = new Set(consumedIds);
+
       const mapped = recent.map((r) => ({
         id: r.id,
         name: r.name,
@@ -188,6 +212,7 @@ export const registerMemorySearchTool = (server: McpServer) => {
         scope: r.scope,
         tags: r.tags,
         createdAt: r.createdAt,
+        accessCount: (r.accessCount ?? 0) + (consumedIdSet.has(r.id) ? 1 : 0),
       }));
 
       return toolOk(

package/src/tools/send-task.ts

@@ -62,8 +62,12 @@ export const sendTaskInputSchema = z
     requiredCapabilities: z
       .array(z.string())
       .optional()
+      .describe("Capabilities required for pool routing."),
+    leadOnly: z
+      .boolean()
+      .default(false)
       .describe(
-        "Capabilities a claiming agent must have (declared via join-swarm/update-profile) to be pool-eligible for this task. Written into the created task's routingAffinity (role is left unset — only enforced when the pool auto-claim/claim-tool paths check it). Most useful when omitting agentId (unassigned pool task); a no-op for a task with an explicit agentId, which bypasses the pool gate entirely.",
+        "Structured authorization constraint for merge or other privileged work. Only Lead agents may be assigned, offered, or claim it; never inferred from task text.",
       ),
     priority: z.number().int().min(0).max(100).optional().describe("Priority 0-100 (default: 50)."),
     dependsOn: z.array(z.uuid()).optional().describe("Task IDs this task depends on."),
@@ -198,6 +202,7 @@ export async function sendTaskHandler(
     taskType,
     tags,
     requiredCapabilities,
+    leadOnly,
     priority,
     dependsOn,
     dir,
@@ -240,6 +245,14 @@ export async function sendTaskHandler(
   const effectiveParentTask = effectiveParentTaskId
     ? await getTaskById(effectiveParentTaskId)
     : null;
+  if (effectiveParentTask?.routingAffinityInvalid) {
+    return toolErr("Cannot continue a task with an invalid routing affinity.", {
+      data: { yourAgentId: creatorAgentId },
+    });
+  }
+  // A public continuation cannot accidentally declassify its parent before
+  // createTaskExtended performs the authoritative merge.
+  const effectiveLeadOnly = leadOnly || effectiveParentTask?.routingAffinity?.leadOnly === true;
 
   // Slack-routing coherence guard: reject a hand-typed slackChannelId/slackThreadTs
   // that disagrees with the parent task or the contextKey this child will inherit.
@@ -423,13 +436,10 @@ export async function sendTaskHandler(
         slackUserId,
         overrideSlackContext,
         followUpConfig,
-        // Only meaningful here: a pool task's routingAffinity gates
-        // claimTask/autoAssignPoolTasks. offer/direct-assign below bypass the
-        // pool gate entirely via an explicit agentId, so requiredCapabilities
-        // is a no-op there.
-        routingAffinity: requiredCapabilities?.length
-          ? { capabilities: requiredCapabilities }
-          : undefined,
+        routingAffinity:
+          effectiveLeadOnly || requiredCapabilities?.length
+            ? { leadOnly: effectiveLeadOnly, capabilities: requiredCapabilities ?? [] }
+            : undefined,
       });
       await transferTrackerSyncToResumeChild({
         parentTaskId: effectiveParentTaskId,
@@ -453,10 +463,10 @@ export async function sendTaskHandler(
       };
     }
 
-    if (agent.isLead) {
+    if (effectiveLeadOnly && !agent.isLead) {
       return {
         success: false,
-        message: `Cannot assign tasks to the lead agent "${agent.name}", wtf?`,
+        message: `Lead-only task requires a Lead agent; "${agent.name}" is not a Lead.`,
       };
     }
 
@@ -492,6 +502,10 @@ export async function sendTaskHandler(
         slackUserId,
         overrideSlackContext,
         followUpConfig,
+        routingAffinity:
+          effectiveLeadOnly || requiredCapabilities?.length
+            ? { leadOnly: effectiveLeadOnly, capabilities: requiredCapabilities ?? [] }
+            : undefined,
       });
       await transferTrackerSyncToResumeChild({
         parentTaskId: effectiveParentTaskId,
@@ -528,6 +542,10 @@ export async function sendTaskHandler(
       slackUserId,
       overrideSlackContext,
       followUpConfig,
+      routingAffinity:
+        effectiveLeadOnly || requiredCapabilities?.length
+          ? { leadOnly: effectiveLeadOnly, capabilities: requiredCapabilities ?? [] }
+          : undefined,
     });
     await transferTrackerSyncToResumeChild({
       parentTaskId: effectiveParentTaskId,

package/src/tools/task-action.ts

@@ -102,8 +102,12 @@ export const taskActionInputSchema = z.object({
   requiredCapabilities: z
     .array(z.string())
     .optional()
+    .describe("Capabilities required for pool routing."),
+  leadOnly: z
+    .boolean()
+    .default(false)
     .describe(
-      "Capabilities a claiming agent must have (declared via join-swarm/update-profile) to be pool-eligible for this task. Written into the created task's routingAffinity (role is left unset). Only used with 'create' action.",
+      "Structured authorization constraint: only Lead agents may claim this privileged task.",
     ),
 });
 
@@ -193,6 +197,7 @@ export async function taskActionHandler(
     dir,
     model,
     requiredCapabilities,
+    leadOnly,
   } = input;
   const normalizedModel = splitLegacyModelAlias({ model, modelTier: input.modelTier });
 
@@ -296,9 +301,10 @@ export async function taskActionHandler(
           model: normalizedModel.model,
           modelTier: normalizedModel.modelTier,
           effort: input.effort,
-          routingAffinity: requiredCapabilities?.length
-            ? { capabilities: requiredCapabilities }
-            : undefined,
+          routingAffinity:
+            leadOnly || requiredCapabilities?.length
+              ? { leadOnly, capabilities: requiredCapabilities ?? [] }
+              : undefined,
         });
         return {
           success: true,
@@ -349,7 +355,9 @@ export async function taskActionHandler(
         if (claimingAgent && !isAgentEligibleForTask(claimingAgent, existingTask)) {
           return {
             success: false,
-            message: `Task "${taskId}" requires role "${existingTask.routingAffinity?.role ?? "(unspecified)"}"; yours is "${claimingAgent.role ?? "(unspecified)"}". Cannot claim.`,
+            message: existingTask.routingAffinity?.leadOnly
+              ? `Task "${taskId}" is Lead-only; you are not authorized to claim it.`
+              : `Task "${taskId}" requires role "${existingTask.routingAffinity?.role ?? "(unspecified)"}"; yours is "${claimingAgent.role ?? "(unspecified)"}". Cannot claim.`,
           };
         }
         // Atomic claim — only one agent can win this race

package/src/types.ts

@@ -152,6 +152,16 @@ export const DEFAULT_MODEL_TIER_MAP: Record<ProviderName, Record<ModelTier, stri
     smart: "devin",
     ultra: "devin",
   },
+  // A generic ACP target owns its own model selection — the swarm never sends
+  // one over the wire. Empty strings resolve to `{ source: "none" }`, while
+  // `MODEL_TIER_*` / `MODEL_TIER_MAP` env overrides still apply for targets
+  // that do accept a model.
+  acp: {
+    smol: "",
+    regular: "",
+    smart: "",
+    ultra: "",
+  },
 };
 
 export function parseModelTier(value: string | null | undefined): ModelTier | undefined {
@@ -344,6 +354,7 @@ export const ProviderNameSchema = z.enum([
   "devin",
   "claude-managed",
   "opencode",
+  "acp",
 ]);
 export type ProviderName = z.infer<typeof ProviderNameSchema>;
 
@@ -433,6 +444,10 @@ export const PROVIDER_STEER_CAPABILITIES: Record<ProviderName, SteerMode[]> = {
   // hook `additionalContext`, so the runner must leave codex rows `pending`
   // (`ProviderSession.steeringDeliveredExternally`).
   codex: ["queue"],
+  // The ACP adapter implements no steering primitive: `session/prompt` is a
+  // single in-flight turn and the only interrupt is `session/cancel` (abort).
+  // Advertise nothing rather than promise semantics we can't honor.
+  acp: [],
 };
 
 export type DevinProviderMeta = {
@@ -451,6 +466,7 @@ export type ProviderMetaMap = {
   pi: NoProviderMeta;
   "claude-managed": NoProviderMeta;
   opencode: NoProviderMeta;
+  acp: NoProviderMeta;
 };
 
 export const FollowUpConfigSchema = z
@@ -475,6 +491,8 @@ export const RoutingAffinitySchema = z
     role: z.string().max(100).optional(),
     harnessProvider: ProviderNameSchema.optional(),
     capabilities: z.array(z.string()).default([]),
+    /** Explicit authorization boundary for merge and other control-plane work. */
+    leadOnly: z.boolean().optional(),
   })
   .openapi("RoutingAffinity");
 export type RoutingAffinity = z.infer<typeof RoutingAffinitySchema>;
@@ -631,6 +649,9 @@ export const AgentTaskSchema = z
     // behavior. Inherited from parentTaskId when not explicitly set (see
     // `createTaskExtended` in src/be/db.ts). See `isAgentEligibleForTask`.
     routingAffinity: RoutingAffinitySchema.optional(),
+    // Stored affinity that fails validation is quarantined rather than silently
+    // treated as an ordinary, claimable task. Internal read-path signal.
+    routingAffinityInvalid: z.boolean().optional(),
   })
   .openapi("AgentTask");
 
@@ -722,8 +743,10 @@ export const CreateTaskOptionsSchema = z.object({
    */
   bypassTrackerContextDedup: z.boolean().optional(),
   /**
-   * Routing-affinity snapshot gating pool eligibility (see
-   * `isAgentEligibleForTask`). Inherited from the parent (via `parentTaskId`)
+   * Routing-affinity snapshot gating task authorization (see
+   * `isAgentEligibleForTask`). `leadOnly: true` is an explicit, structured
+   * constraint: only an agent with `isLead` may be assigned, offered, claim,
+   * or recover this task. It is never inferred from task text. Inherited from the parent (via `parentTaskId`)
    * when not explicitly set — same treatment as `vcsRepo`/`contextKey`.
    */
   routingAffinity: RoutingAffinitySchema.optional(),
@@ -1296,6 +1319,8 @@ export const AgentLogEventTypeSchema = z.enum([
   "task_rejected",
   "task_claimed",
   "task_claim_rejected_affinity",
+  "task_authorization_rejected",
+  "task_recovery_authorization",
   "task_released",
   "channel_message",
   // Service registry events
@@ -2897,6 +2922,10 @@ export const PricingProviderSchema = z.enum([
   "opencode",
   "devin",
   "gemini",
+  // No seeded rate rows: a generic ACP target owns its own billing and the
+  // adapter reports `totalCostUsd: 0`, so these rows settle at
+  // `costSource: 'unpriced'`. Accepted here so the row is recorded at all.
+  "acp",
 ]);
 export type PricingProvider = z.infer<typeof PricingProviderSchema>;
 

package/src/utils/context-window.ts

@@ -27,6 +27,8 @@ export const CONTEXT_FORMULA = "input-cache-output" as const;
 
 const CONTEXT_WINDOW_DEFAULTS: Record<string, number> = {
   // Anthropic Fable / Mythos tier
+  "claude-fable-5-1": 1_000_000,
+  "claude-mythos-5-1": 1_000_000,
   "claude-opus-5": 1_000_000,
   "claude-fable-5": 1_000_000,
   "claude-mythos-5": 1_000_000,

package/src/workflows/approval-notifications.ts

@@ -0,0 +1,72 @@
+import {
+  type ApprovalRequest,
+  claimApprovalCancellationNotification,
+  completeApprovalCancellationNotificationClaim,
+  releaseApprovalCancellationNotificationClaim,
+} from "../be/db";
+import { getSlackApp } from "../slack/app";
+import { scrubSecrets } from "../utils/secret-scrubber";
+
+export interface ApprovalSlackClient {
+  chat: {
+    postMessage(input: {
+      channel: string;
+      thread_ts: string;
+      text: string;
+      unfurl_links: false;
+      unfurl_media: false;
+    }): Promise<unknown>;
+  };
+}
+
+export async function postApprovalCancellationUpdates(
+  approvals: ApprovalRequest[],
+  reason: string,
+  client: ApprovalSlackClient | undefined = getSlackApp()?.client,
+): Promise<void> {
+  if (!client) return;
+
+  const text = `This approval is no longer actionable: ${reason}`;
+  for (const approval of approvals) {
+    const channels = approval.notificationChannels as Array<{
+      channel: string;
+      target: string;
+      messageTs?: string;
+    }> | null;
+    const slackThreads = (channels ?? []).filter(
+      (notification) => notification.channel === "slack" && notification.messageTs,
+    );
+    if (slackThreads.length === 0) continue;
+
+    for (const notification of slackThreads) {
+      if (notification.channel !== "slack" || !notification.messageTs) continue;
+      const notificationKey = `${notification.target}:${notification.messageTs}`;
+      const claim = await claimApprovalCancellationNotification(approval.id, notificationKey);
+      if (!claim) continue;
+      try {
+        await client.chat.postMessage({
+          channel: notification.target,
+          thread_ts: notification.messageTs,
+          text,
+          unfurl_links: false,
+          unfurl_media: false,
+        });
+        await completeApprovalCancellationNotificationClaim(
+          approval.id,
+          notificationKey,
+          claim.leaseToken,
+        );
+      } catch (error) {
+        await releaseApprovalCancellationNotificationClaim(
+          approval.id,
+          notificationKey,
+          claim.leaseToken,
+        );
+        console.error(
+          `[HITL] Failed to post cancellation update for approval ${approval.id}:`,
+          scrubSecrets(error instanceof Error ? error.message : String(error)),
+        );
+      }
+    }
+  }
+}

package/src/workflows/checkpoint.ts

@@ -83,16 +83,23 @@ export async function checkpointStepWaiting(
   runId: string,
   stepId: string,
   ctx: Record<string, unknown>,
-): Promise<void> {
-  await getDbClient().transaction(async () => {
-    await updateWorkflowRunStep(stepId, {
-      status: "waiting",
-    });
+): Promise<boolean> {
+  return getDbClient().transaction(async () => {
+    const step = await getDbClient().get<{ id: string }>(
+      `UPDATE workflow_run_steps
+         SET status = 'waiting'
+       WHERE id = ? AND runId = ? AND status = 'running'
+         AND EXISTS (
+           SELECT 1 FROM workflow_runs
+           WHERE id = ? AND status IN ('running', 'waiting')
+         )
+       RETURNING id`,
+      [stepId, runId, runId],
+    );
+    if (!step) return false;
 
-    await updateWorkflowRun(runId, {
-      status: "waiting",
-      context: ctx,
-    });
+    await updateWorkflowRun(runId, { status: "waiting", context: ctx });
+    return true;
   });
 }
 

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

@@ -0,0 +1,31 @@
+import { getLatestStepForNode } from "../be/db";
+import type { WorkflowDefinition } from "../types";
+import { getSuccessors } from "./definition";
+import { resolveForeachParent } from "./foreach-join";
+
+type CompletedStep = NonNullable<Awaited<ReturnType<typeof getLatestStepForNode>>>;
+
+export async function loadCompletedStepRouting(
+  def: WorkflowDefinition,
+  runId: string,
+  completedNodeIds: Set<string>,
+): Promise<{ activeEdges: Set<string>; stepsByNodeId: Map<string, CompletedStep> }> {
+  const activeEdges = new Set<string>();
+  const stepsByNodeId = new Map<string, CompletedStep>();
+
+  for (const nodeId of completedNodeIds) {
+    if (resolveForeachParent(def, nodeId)) continue;
+
+    const step = await getLatestStepForNode(runId, nodeId);
+    if (step) stepsByNodeId.set(nodeId, step);
+
+    const successors = step?.nextPort
+      ? getSuccessors(def, nodeId, step.nextPort)
+      : getSuccessors(def, nodeId);
+    for (const successor of successors) {
+      activeEdges.add(`${nodeId}→${successor.id}`);
+    }
+  }
+
+  return { activeEdges, stepsByNodeId };
+}