@desplega.ai/agent-swarm 2.5.2 → 2.5.4

package/src/tests/workflow-sub-workflow.test.ts

@@ -1,6 +1,7 @@
-import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { afterAll, beforeAll, describe, expect, spyOn, test } from "bun:test";
 import { unlink } from "node:fs/promises";
 import { z } from "zod";
+import * as preflightAlerts from "../automation-preflight-alert";
 import * as db from "../be/db";
 import {
   closeDb,
@@ -26,9 +27,11 @@ import { MAX_SUB_WORKFLOW_DEPTH, SubWorkflowExecutor } from "../workflows/execut
 import { recoverIncompleteRuns } from "../workflows/recovery";
 import {
   cancelWorkflowRun,
+  resumeFromChildRun,
   resumeWaitState,
   setupWorkflowResumeListener,
 } from "../workflows/resume";
+import { startRetryPoller, stopRetryPoller } from "../workflows/retry-poller";
 
 const TEST_DB_PATH = "./test-workflow-sub-workflow.sqlite";
 
@@ -383,3 +386,537 @@ describe("sub-workflow node", () => {
     expect(rows[0]?.n).toBe(1);
   });
 });
+
+/** A parent run with one `sub-workflow` step row, as executeStep inserts it. */
+async function parentStepRow(parent: Workflow): Promise<{ runId: string; stepId: string }> {
+  const runId = crypto.randomUUID();
+  const stepId = crypto.randomUUID();
+  await db.createWorkflowRun({ id: runId, workflowId: parent.id });
+  await db.updateWorkflowRun(runId, { context: {} });
+  await db.createWorkflowRunStep({
+    id: stepId,
+    runId,
+    nodeId: "child",
+    nodeType: "sub-workflow",
+    idempotencyKey: `${runId}:child:0`,
+  });
+  return { runId, stepId };
+}
+
+/** Runs the sub-workflow executor for the step, as executeStep or the retry poller would. */
+function executeChildStep(parent: Workflow, childId: string, runId: string, stepId: string) {
+  return registry.get("sub-workflow").run({
+    config: { workflowId: childId, inputs: { n: 1 } },
+    context: {},
+    meta: { runId, stepId, nodeId: "child", workflowId: parent.id, dryRun: false },
+  });
+}
+
+async function setStatus(
+  table: "workflow_runs" | "workflow_run_steps",
+  id: string,
+  status: string,
+): Promise<void> {
+  await getDbClient().run(`UPDATE ${table} SET status = ? WHERE id = ?`, [status, id]);
+}
+
+async function fireChildWait(childRunId: string): Promise<void> {
+  const [childStep] = await getWorkflowRunStepsByRunId(childRunId);
+  const wait = await getWaitStateByStepId(childStep!.id);
+  await resumeWaitState(wait!.id, "fired", undefined, registry);
+}
+
+async function attemptsOf(workflowId: string): Promise<{ id: string; attempt: number }[]> {
+  return getDbClient().query<{ id: string; attempt: number }>(
+    "SELECT id, parentStepAttempt AS attempt FROM workflow_runs WHERE workflowId = ? ORDER BY parentStepAttempt",
+    [workflowId],
+  );
+}
+
+describe("sub-workflow crash recovery", () => {
+  test("recovery re-claims a parent step left running and reconnects to its child", async () => {
+    const child = await makeWorkflow(waitingChild);
+    const parent = await makeWorkflow(parentOf(child.id));
+    const runId = await startWorkflowExecution(parent, {}, registry);
+    const childRun = await childRunOf(child.id, "waiting");
+    const [step] = await getWorkflowRunStepsByRunId(runId);
+
+    // The crash hit after the child committed and before the step parked.
+    await setStatus("workflow_run_steps", step!.id, "running");
+    await setStatus("workflow_runs", runId, "running");
+    await recoverIncompleteRuns(registry);
+
+    const steps = await getWorkflowRunStepsByRunId(runId);
+    expect(steps.map((s) => [s.id, s.status, s.retryCount])).toEqual([[step!.id, "waiting", 0]]);
+    expect(await childRunsOf(child.id)).toHaveLength(1);
+
+    await fireChildWait(childRun.id);
+    const run = await waitForRun(runId, isDone);
+    expect(run.status).toBe("completed");
+    expect((run.context?.child as { runId: string }).runId).toBe(childRun.id);
+  });
+
+  test("recovery re-claims a running parent step in a run another branch parked", async () => {
+    const child = await makeWorkflow(waitingChild);
+    const parent = await makeWorkflow(parentOf(child.id));
+    const runId = await startWorkflowExecution(parent, {}, registry);
+    await childRunOf(child.id, "waiting");
+    const [step] = await getWorkflowRunStepsByRunId(runId);
+
+    await setStatus("workflow_run_steps", step!.id, "running");
+    expect((await getWorkflowRun(runId))?.status).toBe("waiting");
+    await recoverIncompleteRuns(registry);
+
+    const steps = await getWorkflowRunStepsByRunId(runId);
+    expect(steps.map((s) => [s.id, s.status])).toEqual([[step!.id, "waiting"]]);
+    expect(await childRunsOf(child.id)).toHaveLength(1);
+  });
+
+  test("a child committed before its walk started runs from its stored context", async () => {
+    const child = await makeWorkflow(instantChild);
+    const parent = await makeWorkflow(parentOf(child.id));
+    const { runId, stepId } = await parentStepRow(parent);
+    // What startWorkflowExecution commits for a child, with no walk after it.
+    const childRunId = crypto.randomUUID();
+    await getDbClient().transaction(async () => {
+      await db.createWorkflowRun({
+        id: childRunId,
+        workflowId: child.id,
+        parentStepId: stepId,
+        parentStepAttempt: 0,
+      });
+      await db.updateWorkflowRun(childRunId, { context: { trigger: { n: 1 } } });
+    });
+
+    await recoverIncompleteRuns(registry);
+
+    const run = await waitForRun(runId, isDone);
+    expect(run.status).toBe("completed");
+    const output = run.context?.child as { runId: string; outputs: Record<string, unknown> };
+    expect(output.runId).toBe(childRunId);
+    expect(output.outputs.check).toMatchObject({ passed: true });
+    expect(await childRunsOf(child.id)).toHaveLength(1);
+  });
+
+  test("recovery fails a child run that never stored its initial context", async () => {
+    const child = await makeWorkflow(instantChild);
+    const parent = await makeWorkflow(parentOf(child.id));
+    const { runId, stepId } = await parentStepRow(parent);
+    const childRunId = crypto.randomUUID();
+    await db.createWorkflowRun({ id: childRunId, workflowId: child.id, parentStepId: stepId });
+
+    await recoverIncompleteRuns(registry);
+
+    const childRun = await waitForRun(childRunId, isDone);
+    expect(childRun.status).toBe("failed");
+    expect(childRun.error).toContain("lost its initial context");
+    expect(await getWorkflowRunStepsByRunId(childRunId)).toHaveLength(0);
+    const run = await waitForRun(runId, isDone);
+    expect(run.status).toBe("failed");
+    expect(await childRunsOf(child.id)).toHaveLength(1);
+  });
+
+  test("concurrent executions of one attempt share one child", async () => {
+    const child = await makeWorkflow(waitingChild);
+    const parent = await makeWorkflow(parentOf(child.id));
+    const { runId, stepId } = await parentStepRow(parent);
+
+    const results = await Promise.all([
+      executeChildStep(parent, child.id, runId, stepId),
+      executeChildStep(parent, child.id, runId, stepId),
+    ]);
+
+    const [row] = await childRunsOf(child.id);
+    expect(await childRunsOf(child.id)).toHaveLength(1);
+    for (const result of results) expect(result).toMatchObject({ correlationId: row!.id });
+  });
+
+  test("a step that is no longer running starts no child", async () => {
+    const child = await makeWorkflow(waitingChild);
+    const parent = await makeWorkflow(parentOf(child.id));
+    const { runId, stepId } = await parentStepRow(parent);
+    await setStatus("workflow_run_steps", stepId, "cancelled");
+
+    const result = await executeChildStep(parent, child.id, runId, stepId);
+
+    expect(result.status).toBe("failed");
+    expect((result as { error?: string }).error).toContain("no longer running");
+    expect(await childRunsOf(child.id)).toHaveLength(0);
+  });
+
+  test("an existing child of another workflow is a conflict, not replaced", async () => {
+    const child = await makeWorkflow(waitingChild);
+    const other = await makeWorkflow(waitingChild);
+    const parent = await makeWorkflow(parentOf(child.id));
+    const { runId, stepId } = await parentStepRow(parent);
+    await executeChildStep(parent, child.id, runId, stepId);
+
+    const result = await executeChildStep(parent, other.id, runId, stepId);
+
+    expect(result.status).toBe("failed");
+    expect((result as { error?: string }).error).toContain(`not ${other.id}`);
+    expect(await childRunsOf(child.id)).toHaveLength(1);
+    expect(await childRunsOf(other.id)).toHaveLength(0);
+  });
+
+  test("a retry attempt starts its own child and the old one cannot settle it", () =>
+    withoutListener(async () => {
+      const child = await makeWorkflow(waitingChild);
+      const parent = await makeWorkflow(parentOf(child.id));
+      const { runId, stepId } = await parentStepRow(parent);
+      await executeChildStep(parent, child.id, runId, stepId);
+      const first = await childRunOf(child.id, "waiting");
+
+      // The retry poller re-runs the same step id with retryCount bumped.
+      await db.updateWorkflowRunStep(stepId, { retryCount: 1 });
+      const retried = await executeChildStep(parent, child.id, runId, stepId);
+      const again = await executeChildStep(parent, child.id, runId, stepId);
+      const attempts = await attemptsOf(child.id);
+      expect(attempts.map((a) => a.attempt)).toEqual([0, 1]);
+      const second = attempts[1]!.id;
+      expect(retried).toMatchObject({ correlationId: second });
+      expect(again).toMatchObject({ correlationId: second });
+      await waitForRun(second, (r) => r.status === "waiting");
+
+      await setStatus("workflow_run_steps", stepId, "waiting");
+      await setStatus("workflow_runs", runId, "waiting");
+      await fireChildWait(first.id);
+      expect((await getWorkflowRun(first.id))?.status).toBe("completed");
+      expect(await resumeFromChildRun(stepId, registry)).toBe(false);
+      await recoverIncompleteRuns(registry);
+      expect((await db.getWorkflowRunStep(stepId))?.status).toBe("waiting");
+
+      await fireChildWait(second);
+      expect(await resumeFromChildRun(stepId, registry)).toBe(true);
+      const step = await db.getWorkflowRunStep(stepId);
+      expect(step?.status).toBe("completed");
+      expect((step?.output as { runId: string }).runId).toBe(second);
+    }));
+
+  test("the live event and the recovery sweep settle the parent once", () =>
+    withoutListener(async () => {
+      const child = await makeWorkflow(waitingChild);
+      const parent = await makeWorkflow(parentOf(child.id));
+      const runId = await startWorkflowExecution(parent, {}, registry);
+      const childRun = await childRunOf(child.id, "waiting");
+      const [step] = await getWorkflowRunStepsByRunId(runId);
+      await fireChildWait(childRun.id);
+
+      const claims = await Promise.all([
+        resumeFromChildRun(step!.id, registry),
+        resumeFromChildRun(step!.id, registry),
+      ]);
+      expect(claims.filter(Boolean)).toHaveLength(1);
+      await recoverIncompleteRuns(registry);
+
+      expect((await getWorkflowRun(runId))?.status).toBe("completed");
+      expect(await getWorkflowRunStepsByRunId(runId)).toHaveLength(1);
+    }));
+
+  test("a cancelled parent run is not overwritten by its child finishing", async () => {
+    const child = await makeWorkflow(waitingChild);
+    const parent = await makeWorkflow(parentOf(child.id));
+    const runId = await startWorkflowExecution(parent, {}, registry);
+    const childRun = await childRunOf(child.id, "waiting");
+    await cancelWorkflowRun(runId, "stop");
+    const [step] = await getWorkflowRunStepsByRunId(runId);
+
+    await fireChildWait(childRun.id);
+    expect(await resumeFromChildRun(step!.id, registry)).toBe(false);
+    await recoverIncompleteRuns(registry);
+
+    expect((await getWorkflowRun(runId))?.status).toBe("cancelled");
+    expect((await db.getWorkflowRunStep(step!.id))?.status).not.toBe("completed");
+  });
+});
+
+/** Retries at once, so the poller picks the step up on its next tick. */
+const immediateRetry = {
+  maxRetries: 1,
+  strategy: "static",
+  baseDelayMs: 0,
+  maxDelayMs: 0,
+} as const;
+
+/** A child that parks on a wait and then fails, so it fails after the parent step parked. */
+const failsAfterParkChild: WorkflowDefinition = {
+  nodes: [
+    { id: "pause", type: "wait", config: { mode: "time", durationMs: 3_600_000 }, next: "bad" },
+    { id: "bad", type: "property-match", config: { conditions: [] } },
+  ],
+};
+
+function retryingParentOf(childId: string): WorkflowDefinition {
+  const def = parentOf(childId);
+  def.nodes[0]!.retry = { ...immediateRetry };
+  return def;
+}
+
+async function waitFor<T>(read: () => Promise<T>, done: (value: T) => boolean): Promise<T> {
+  for (let i = 0; i < 250; i++) {
+    const value = await read();
+    if (done(value)) return value;
+    await Bun.sleep(20);
+  }
+  throw new Error("condition not reached");
+}
+
+describe("sub-workflow attempts", () => {
+  test("a stale execution writes nothing over a cancelled step", async () => {
+    // Cancels the parent run while the child is being prepared, as a user
+    // cancel landing mid-execution would.
+    class CancelFirstExecutor extends SubWorkflowExecutor {
+      override async run(input: ExecutorInput) {
+        await cancelWorkflowRun(input.meta.runId, "stop");
+        return super.run(input);
+      }
+    }
+    const cancelRegistry = createExecutorRegistry(deps);
+    cancelRegistry.register(new CancelFirstExecutor(deps, cancelRegistry));
+    const child = await makeWorkflow(waitingChild);
+    const parent = await makeWorkflow(retryingParentOf(child.id));
+
+    const runId = await startWorkflowExecution(parent, {}, cancelRegistry);
+
+    expect((await getWorkflowRun(runId))?.status).toBe("cancelled");
+    const [step] = await getWorkflowRunStepsByRunId(runId);
+    expect(step?.status).toBe("cancelled");
+    expect(step?.retryCount).toBe(0);
+    expect(step?.nextRetryAt ?? null).toBeNull();
+    expect(await childRunsOf(child.id)).toHaveLength(0);
+  });
+
+  test("a child cancelled before the step parked is not retried either", async () => {
+    // The cancel lands between the child's creation and the executor's read,
+    // so the executor settles the cancelled child synchronously.
+    class CancelChildExecutor extends SubWorkflowExecutor {
+      override async run(input: ExecutorInput) {
+        const started = await super.run(input);
+        const { correlationId } = started as { correlationId?: string };
+        if (correlationId) await cancelWorkflowRun(correlationId, "stop");
+        return super.run(input);
+      }
+    }
+    const cancelRegistry = createExecutorRegistry(deps);
+    cancelRegistry.register(new CancelChildExecutor(deps, cancelRegistry));
+    const child = await makeWorkflow(waitingChild);
+    const parent = await makeWorkflow(retryingParentOf(child.id));
+
+    const runId = await startWorkflowExecution(parent, {}, cancelRegistry);
+
+    const run = await waitForRun(runId, isDone);
+    expect(run.status).toBe("failed");
+    const [step] = await getWorkflowRunStepsByRunId(runId);
+    expect(step?.error).toContain("cancelled");
+    expect(step?.retryCount).toBe(0);
+    expect(step?.nextRetryAt ?? null).toBeNull();
+    expect(await childRunsOf(child.id)).toHaveLength(1);
+  });
+
+  test("a stale failure does not write its output", async () => {
+    class CancelThenFailExecutor extends BaseExecutor<z.ZodObject, z.ZodObject> {
+      readonly type = "test-cancel-then-fail";
+      readonly mode = "instant" as const;
+      readonly configSchema = z.object({});
+      readonly outputSchema = z.object({});
+
+      protected async execute(
+        _config: Record<string, never>,
+        _context: Readonly<Record<string, unknown>>,
+        meta: ExecutorInput["meta"],
+      ): Promise<ExecutorResult<Record<string, never>>> {
+        await cancelWorkflowRun(meta.runId, "stop");
+        return { status: "failed", error: "boom", output: { late: true } as never };
+      }
+    }
+    const staleRegistry = createExecutorRegistry(deps);
+    staleRegistry.register(new CancelThenFailExecutor(deps));
+    const wf = await makeWorkflow({
+      nodes: [{ id: "x", type: "test-cancel-then-fail", config: {} }],
+    });
+
+    const runId = await startWorkflowExecution(wf, {}, staleRegistry);
+
+    const [step] = await getWorkflowRunStepsByRunId(runId);
+    expect(step?.status).toBe("cancelled");
+    expect(step?.output).toBeUndefined();
+    expect((await getWorkflowRun(runId))?.status).toBe("cancelled");
+  });
+
+  test("a child failing after the step parked is retried as a new attempt", async () => {
+    const child = await makeWorkflow(failsAfterParkChild);
+    const parent = await makeWorkflow(retryingParentOf(child.id));
+    startRetryPoller(registry, 20);
+    try {
+      const runId = await startWorkflowExecution(parent, {}, registry);
+      const first = await childRunOf(child.id, "waiting");
+      const [step] = await getWorkflowRunStepsByRunId(runId);
+
+      await fireChildWait(first.id);
+
+      const attempts = await waitFor(
+        () => attemptsOf(child.id),
+        (rows) => rows.length === 2,
+      );
+      expect(attempts.map((a) => a.attempt)).toEqual([0, 1]);
+      expect((await getWorkflowRun(first.id))?.status).toBe("failed");
+      const second = await waitForRun(attempts[1]!.id, (r) => r.status === "waiting");
+      const parked = await waitFor(
+        () => db.getWorkflowRunStep(step!.id),
+        (row) => row?.status === "waiting",
+      );
+      expect(parked?.retryCount).toBe(1);
+      expect(await getWorkflowRunStepsByRunId(runId)).toHaveLength(1);
+
+      // The last attempt failing exhausts the policy and fails the run.
+      await fireChildWait(second.id);
+      const run = await waitForRun(runId, isDone);
+      expect(run.status).toBe("failed");
+      expect(run.error).toContain(second.id);
+      expect(await childRunsOf(child.id)).toHaveLength(2);
+    } finally {
+      stopRetryPoller();
+    }
+  });
+
+  test("a cancelled child is not retried", async () => {
+    const child = await makeWorkflow(waitingChild);
+    const parent = await makeWorkflow(retryingParentOf(child.id));
+    const runId = await startWorkflowExecution(parent, {}, registry);
+    const childRun = await childRunOf(child.id, "waiting");
+
+    await cancelWorkflowRun(childRun.id, "stop");
+
+    const run = await waitForRun(runId, isDone);
+    expect(run.status).toBe("failed");
+    const [step] = await getWorkflowRunStepsByRunId(runId);
+    expect(step?.retryCount).toBe(0);
+    expect(await childRunsOf(child.id)).toHaveLength(1);
+  });
+
+  test("runs expose the parent step attempt", async () => {
+    const child = await makeWorkflow(waitingChild);
+    const parent = await makeWorkflow(parentOf(child.id));
+    const { runId, stepId } = await parentStepRow(parent);
+    await executeChildStep(parent, child.id, runId, stepId);
+    await db.updateWorkflowRunStep(stepId, { retryCount: 1 });
+    await executeChildStep(parent, child.id, runId, stepId);
+
+    const [first, second] = await attemptsOf(child.id);
+    expect(await getWorkflowRun(first!.id, "display")).toMatchObject({
+      parentStepId: stepId,
+      parentStepAttempt: 0,
+    });
+    expect((await getWorkflowRun(second!.id, "display"))?.parentStepAttempt).toBe(1);
+    expect((await getWorkflowRun(runId))?.parentStepAttempt).toBeUndefined();
+
+    const page = await db.listWorkflowRunsPage(child.id, { limit: 10, offset: 0 });
+    expect(
+      page.runs
+        .map((r) => [r.parentStepId, r.parentStepAttempt])
+        .sort((a, b) => Number(a[1]) - Number(b[1])),
+    ).toEqual([
+      [stepId, 0],
+      [stepId, 1],
+    ]);
+  });
+
+  test("a child that needs setup keeps its parent link and attempt", async () => {
+    const notify = spyOn(preflightAlerts, "notifyAutomationPreflightFailure").mockResolvedValue(
+      undefined,
+    );
+    try {
+      const child = await createWorkflow({
+        name: `wf-${crypto.randomUUID()}`,
+        definition: instantChild,
+        requiredParams: ["REPO_URL"],
+      });
+      const parent = await makeWorkflow(parentOf(child.id));
+
+      const runId = await startWorkflowExecution(parent, {}, registry);
+
+      expect((await waitForRun(runId, isDone)).status).toBe("failed");
+      const [step] = await getWorkflowRunStepsByRunId(runId);
+      const [linked] = await childRunsOf(child.id);
+      const linkedRun = await getWorkflowRun(linked!.id);
+      expect(linkedRun).toMatchObject({ parentStepId: step!.id, parentStepAttempt: 0 });
+      expect(linkedRun?.status).toBe("failed");
+      expect(linkedRun?.error).toStartWith("needs_setup:");
+      expect(step?.error).toContain(linked!.id);
+
+      // A top-level trigger records its own unlinked failure, and the day's
+      // alert already went out.
+      const topLevel = await startWorkflowExecution(child, {}, registry);
+      expect(topLevel).not.toBe(linked!.id);
+      expect((await getWorkflowRun(topLevel))?.parentStepId).toBeUndefined();
+      expect(notify).toHaveBeenCalledTimes(1);
+    } finally {
+      notify.mockRestore();
+    }
+  });
+
+  test("concurrent child setup failures alert exactly once", async () => {
+    const notify = spyOn(preflightAlerts, "notifyAutomationPreflightFailure").mockResolvedValue(
+      undefined,
+    );
+    try {
+      const child = await createWorkflow({
+        name: `wf-${crypto.randomUUID()}`,
+        definition: instantChild,
+        requiredParams: ["REPO_URL"],
+      });
+      // Two entry nodes run in parallel, so both failures race for the alert.
+      const parent = await makeWorkflow({
+        nodes: ["a", "b"].map((id) => ({
+          id,
+          type: "sub-workflow",
+          config: { workflowId: child.id, inputs: { n: 1 } },
+        })),
+      });
+
+      const runId = await startWorkflowExecution(parent, {}, registry);
+
+      expect((await waitForRun(runId, isDone)).status).toBe("failed");
+      expect(await childRunsOf(child.id)).toHaveLength(2);
+      expect(notify).toHaveBeenCalledTimes(1);
+    } finally {
+      notify.mockRestore();
+    }
+  });
+
+  test("a legacy child started on a later attempt survives the upgrade", () =>
+    withoutListener(async () => {
+      // On main before migration 240: attempt 0 failed before starting a child
+      // (say, the child workflow was disabled), attempt 1 started it and parked.
+      const child = await makeWorkflow(waitingChild);
+      const parent = await makeWorkflow(parentOf(child.id));
+      const { runId, stepId } = await parentStepRow(parent);
+      await db.updateWorkflowRunStep(stepId, { retryCount: 1 });
+      await executeChildStep(parent, child.id, runId, stepId);
+      await setStatus("workflow_run_steps", stepId, "waiting");
+      await setStatus("workflow_runs", runId, "waiting");
+      const childRun = await childRunOf(child.id, "waiting");
+      // The column default the upgrade gives every legacy child.
+      await getDbClient().run("UPDATE workflow_runs SET parentStepAttempt = 0 WHERE id = ?", [
+        childRun.id,
+      ]);
+
+      // The backfill statement of migration 240, scoped to this child: the
+      // shared test database also holds post-migration multi-attempt children,
+      // which a real legacy database cannot have.
+      const migration = await Bun.file(
+        "src/be/migrations/240_workflow_run_parent_step_attempt.sql",
+      ).text();
+      const start = migration.indexOf("UPDATE workflow_runs");
+      const backfill = migration.slice(start, migration.indexOf(";", start));
+      await getDbClient().run(`${backfill} AND workflow_runs.id = ?`, [childRun.id]);
+      await recoverIncompleteRuns(registry);
+
+      expect((await getWorkflowRun(runId))?.status).toBe("waiting");
+      expect((await db.getWorkflowRunStep(stepId))?.status).toBe("waiting");
+      await fireChildWait(childRun.id);
+      expect(await resumeFromChildRun(stepId, registry)).toBe(true);
+      expect((await getWorkflowRun(runId))?.status).toBe("completed");
+      expect(await childRunsOf(child.id)).toHaveLength(1);
+    }));
+});

package/src/tools/request-human-input.ts

@@ -1,5 +1,9 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as z from "zod";
+import {
+  ConfigQuestionSettingsSchema,
+  normalizeApprovalQuestions,
+} from "@/be/approval-config-question";
 import { resolveTaskAuditUserId } from "@/be/audit-user";
 import { createApprovalRequest, getAgentCurrentTask } from "@/be/db";
 import { createToolRegistrar, swarmToolOutputSchema, toolErr, toolOk } from "@/tools/utils";
@@ -8,9 +12,14 @@ import { getAppUrl } from "@/utils/constants";
 const QuestionSchema = z.object({
   id: z.string().describe("Unique ID for the question (used as key in responses)"),
   type: z
-    .enum(["approval", "text", "single-select", "multi-select", "boolean"])
+    .enum(["approval", "text", "single-select", "multi-select", "boolean", "config"])
     .describe("Question type"),
-  label: z.string().describe("The question text displayed to the user"),
+  label: z
+    .string()
+    .optional()
+    .describe(
+      "The question text displayed to the user (required except for config, which defaults to the key)",
+    ),
   required: z.boolean().optional().describe("Whether this question is required (default: true)"),
   description: z
     .string()
@@ -31,6 +40,9 @@ const QuestionSchema = z.object({
   minSelections: z.number().int().min(0).optional().describe("Min selections (for multi-select)"),
   maxSelections: z.number().int().min(1).optional().describe("Max selections (for multi-select)"),
   defaultValue: z.boolean().optional().describe("Default value (for boolean type)"),
+  config: ConfigQuestionSettingsSchema.optional().describe(
+    "Settings for a config question: the key and scope to set, plus options or defaultValue for non-secret keys",
+  ),
 });
 
 export const registerRequestHumanInputTool = (server: McpServer) => {
@@ -42,7 +54,8 @@ export const registerRequestHumanInputTool = (server: McpServer) => {
       description:
         "Create an approval request and return at once with the request id and URL. The answer arrives later as a hitl-follow-up task. " +
         "Supports multiple question types: approval (yes/no), text, single-select, " +
-        "multi-select, and boolean. Returns the request ID and URL for the human to respond. " +
+        "multi-select, boolean, and config. Returns the request ID and URL for the human to respond. " +
+        "config asks a person to set one swarm config key on the dashboard; secrets are stored encrypted and you receive only {key, scope, isSecret, status, updatedAt}, never the value. " +
         "The dashboard renders each label and description as markdown: put long content in description, fence code with a language, and put an image URL alone on its own line to show it. " +
         "No Slack message is sent; share the URL yourself.",
       inputSchema: z.object({
@@ -90,12 +103,21 @@ export const registerRequestHumanInputTool = (server: McpServer) => {
         }
       }
 
+      const approvers = { policy: "any" as const };
+      const normalized = await normalizeApprovalQuestions(questions, {
+        approvers,
+        callerAgentId: requestInfo.agentId,
+      });
+      if (!normalized.ok) {
+        return toolErr(normalized.error, { data: { yourAgentId: requestInfo.agentId } });
+      }
+
       const id = crypto.randomUUID();
       const request = await createApprovalRequest({
         id,
         title,
-        questions,
-        approvers: { policy: "any" },
+        questions: normalized.questions,
+        approvers,
         sourceTaskId: sourceTaskId ?? undefined,
         timeoutSeconds,
         createdBy: (await resolveTaskAuditUserId(sourceTaskId, requestInfo.agentId)) ?? undefined,

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

@@ -10,7 +10,7 @@ export const registerCancelWorkflowRunTool = (server: McpServer) => {
       title: "Cancel Workflow Run",
       annotations: { destructiveHint: true },
       description:
-        "Cancel a running or waiting workflow run. Cancels all non-terminal steps and their associated tasks.",
+        "Cancel a running or waiting workflow run and every child run below it. Cancels their non-terminal steps, tasks, pending approvals and queued retries in one transaction; finished child runs keep their status. Repeating the cancel on a cancelled run finishes any child runs still open.",
       inputSchema: z.object({
         runId: z.string().uuid().describe("Workflow run ID to cancel"),
         reason: z.string().optional().describe("Optional reason for cancellation"),

package/src/types.ts

@@ -2958,6 +2958,13 @@ export const WorkflowRunSchema = z
     finishedAt: z.string().optional(),
     /** The `sub-workflow` step that started this run. Unset on a top-level run. */
     parentStepId: z.string().optional(),
+    /**
+     * The parent step's attempt (its `retryCount`) that started this run. A
+     * step has at most one child per attempt, so `(parentStepId,
+     * parentStepAttempt)` identifies the invocation; a node `retry` adds a
+     * child with the next attempt. Unset on a top-level run.
+     */
+    parentStepAttempt: z.number().int().min(0).optional(),
   })
   .openapi("WorkflowRun");
 

package/src/utils/context-window.ts

@@ -67,7 +67,12 @@ function catalogContext(provider: string, model: string): number | undefined {
  * Unknown models get a conservative 200k so percent math stays finite.
  */
 export function getContextWindowSize(model: string): number {
-  if (!model) return DEFAULT_CONTEXT_WINDOW;
+  return getKnownContextWindowSize(model) ?? DEFAULT_CONTEXT_WINDOW;
+}
+
+/** {@link getContextWindowSize} without the fallback: undefined when the catalog has no window. */
+export function getKnownContextWindowSize(model: string | undefined): number | undefined {
+  if (!model) return undefined;
   const slash = model.indexOf("/");
   if (slash > 0) {
     const scoped = catalogContext(model.slice(0, slash), model.slice(slash + 1));
@@ -83,11 +88,8 @@ export function getContextWindowSize(model: string): number {
     if (dated) return dated;
   }
   const shortname = resolveClaudeShortname(model);
-  if (shortname) {
-    const resolved = catalogContext("anthropic", shortname);
-    if (resolved) return resolved;
-  }
-  return DEFAULT_CONTEXT_WINDOW;
+  if (shortname) return catalogContext("anthropic", shortname);
+  return undefined;
 }
 
 /**