@desplega.ai/agent-swarm 1.147.0 → 1.149.0

package/src/tests/defer-task.test.ts

@@ -22,6 +22,7 @@ import {
   createWorkflow,
   createWorkflowRun,
   createWorkflowRunStep,
+  getLogsByTaskId,
   getScheduledTasks,
   getTaskById,
   initDb,
@@ -183,7 +184,9 @@ describe("defer-task handler", () => {
     const stored = await getTaskById(task.id);
     expect(stored?.status).toBe("completed");
     // Summary first, then the deferral status line, then the checks.
-    expect(stored?.output?.startsWith(`${SUMMARY}\n\n`)).toBe(true);
+    expect(stored?.output).toBe(
+      `${SUMMARY}\n\nDeferred until ${schedule.nextRunAt} (schedule ${schedule.id}). Pending: deploy 42 is still running\n\nChecks:\n- deploy 42 status is green\n- smoke tests pass`,
+    );
     expect(stored?.output).toContain("Pending: deploy 42 is still running");
     expect(stored?.output).toContain(schedule.nextRunAt!);
     expect(stored?.output).toContain(schedule.id);
@@ -313,7 +316,7 @@ describe("defer-task handler", () => {
     expect((await getTaskById(task.id))?.status).toBe("in_progress");
   });
 
-  test("a task with an outputSchema refuses a prose deferral and books no schedule", async () => {
+  test("a task with an outputSchema requires explicit output and books no schedule", async () => {
     const task = await startedTask("structured output task", agentId, {
       outputSchema: {
         type: "object",
@@ -328,13 +331,103 @@ describe("defer-task handler", () => {
     )) as DeferTaskResult;
 
     expect(result.structuredContent.success).toBe(false);
-    expect(result.structuredContent.message).toContain("outputSchema");
+    expect(result.structuredContent.message).toContain(
+      "Call defer-task with output: a JSON string",
+    );
     expect((await schedulesForTask(task.id)).length).toBe(0);
     const stored = await getTaskById(task.id);
     expect(stored?.status).toBe("in_progress");
     expect(stored?.output).toBeFalsy();
   });
 
+  test("valid schema output is preserved verbatim and deferral details are logged", async () => {
+    const task = await startedTask("structured deferral", agentId, {
+      outputSchema: {
+        type: "object",
+        required: ["result"],
+        properties: { result: { type: "string" } },
+      },
+    });
+    const output = ' { "result": "deploy pending" }\n';
+    const result = (await buildTool().handler(
+      {
+        taskId: task.id,
+        delayMs: 60_000,
+        summary: SUMMARY,
+        note: "pending deploy",
+        checks: ["check deploy"],
+        output,
+      },
+      meta(),
+    )) as DeferTaskResult;
+
+    expect(result.structuredContent.success).toBe(true);
+    const stored = await getTaskById(task.id);
+    expect(stored?.status).toBe("completed");
+    expect(stored?.output).toBe(output);
+    const schedules = await schedulesForTask(task.id);
+    expect(schedules).toHaveLength(1);
+    const schedule = schedules[0]!;
+    expect(schedule.taskTemplate).toBe(
+      `Resume task ${task.id}: pending deploy\n\nChecks:\n- check deploy`,
+    );
+    const logs = (await getLogsByTaskId(task.id)).filter(
+      (log) => log.eventType === "task_progress",
+    );
+    expect(logs).toHaveLength(1);
+    expect(logs[0]!.newValue).toBe(
+      `${SUMMARY}\n\nDeferred until ${schedule.nextRunAt} (schedule ${schedule.id}). Pending: pending deploy\n\nChecks:\n- check deploy`,
+    );
+  });
+
+  test.each([
+    "not JSON",
+    '{"result": 42}',
+  ])("invalid schema output %s has no side effects", async (output) => {
+    const task = await startedTask("invalid structured deferral", agentId, {
+      outputSchema: {
+        type: "object",
+        required: ["result"],
+        properties: { result: { type: "string" } },
+      },
+    });
+    const result = (await buildTool().handler(
+      { taskId: task.id, delayMs: 60_000, summary: SUMMARY, note: "pending", output },
+      meta(),
+    )) as DeferTaskResult;
+    expect(result.structuredContent.success).toBe(false);
+    expect(result.structuredContent.message).toContain("outputSchema");
+    expect(await schedulesForTask(task.id)).toHaveLength(0);
+    expect((await getTaskById(task.id))?.status).toBe("in_progress");
+    expect((await getTaskById(task.id))?.output).toBeFalsy();
+    expect(
+      (await getLogsByTaskId(task.id)).filter((log) => log.eventType === "task_progress"),
+    ).toHaveLength(0);
+  });
+
+  test("JSON string schema output can defer", async () => {
+    const task = await startedTask("string output", agentId, { outputSchema: { type: "string" } });
+    const output = '"pending"';
+    const result = (await buildTool().handler(
+      { taskId: task.id, delayMs: 60_000, summary: SUMMARY, note: "pending", output },
+      meta(),
+    )) as DeferTaskResult;
+    expect(result.structuredContent.success).toBe(true);
+    expect((await getTaskById(task.id))?.output).toBe(output);
+  });
+
+  test("explicit output is ignored without a schema", async () => {
+    const task = await startedTask("unstructured output");
+    const result = (await buildTool().handler(
+      { taskId: task.id, delayMs: 60_000, summary: SUMMARY, note: "pending", output: '"ignored"' },
+      meta(),
+    )) as DeferTaskResult;
+    expect(result.structuredContent.success).toBe(true);
+    expect((await getTaskById(task.id))?.output).toBe(
+      `${SUMMARY}\n\nDeferred until ${result.structuredContent.nextRunAt} (schedule ${result.structuredContent.scheduleId}). Pending: pending`,
+    );
+  });
+
   test("the wake-up schedule carries modelTier but never the parent's concrete model", async () => {
     const task = await startedTask("pinned model task", agentId, {
       model: "claude-sonnet-5",
@@ -353,15 +446,27 @@ describe("defer-task handler", () => {
   });
 
   test("a competing terminal transition between schedule creation and completion aborts the loser and books no orphan schedule", async () => {
-    const task = await startedTask("race target");
+    const task = await startedTask("race target", agentId, { outputSchema: { type: "string" } });
 
     const [first, second] = (await Promise.all([
       buildTool().handler(
-        { taskId: task.id, delayMs: 60_000, summary: "first writer", note: "pending A" },
+        {
+          taskId: task.id,
+          delayMs: 60_000,
+          summary: "first writer",
+          note: "pending A",
+          output: '"first"',
+        },
         meta(),
       ),
       buildTool().handler(
-        { taskId: task.id, delayMs: 90_000, summary: "second writer", note: "pending B" },
+        {
+          taskId: task.id,
+          delayMs: 90_000,
+          summary: "second writer",
+          note: "pending B",
+          output: '"second"',
+        },
         meta(),
       ),
     ])) as [DeferTaskResult, DeferTaskResult];
@@ -378,6 +483,12 @@ describe("defer-task handler", () => {
     expect(failed.length).toBe(1);
     expect(failed[0]!.structuredContent.message).toContain("terminal state");
 
+    const logs = (await getLogsByTaskId(task.id)).filter(
+      (log) => log.eventType === "task_progress",
+    );
+    expect(logs).toHaveLength(1);
+    expect(logs[0]!.newValue).toContain(succeeded[0]!.structuredContent.scheduleId!);
+
     // The loser's schedule INSERT rolled back with its transaction — only
     // the winner's wake-up was committed. No orphan schedule.
     const schedules = await schedulesForTask(task.id);

package/src/tests/deferred-task-wake.test.ts

@@ -0,0 +1,456 @@
+import { afterAll, afterEach, beforeAll, describe, expect, test } from "bun:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import {
+  cancelTask,
+  closeDb,
+  completeTask,
+  createAgent,
+  createScheduledTask,
+  createTaskExtended,
+  deleteScheduledTask,
+  failTask,
+  getDbClient,
+  getLogsByTaskId,
+  getScheduledTaskById,
+  getTaskById,
+  initDb,
+  startTask,
+  updateScheduledTask,
+} from "../be/db";
+import {
+  dispatchDeferredTaskWait,
+  initDeferredTaskWaits,
+  reconcileDeferredTaskWaits,
+  stopDeferredTaskWaits,
+  type TaskWakeEvent,
+} from "../scheduler/deferred-task-waits";
+import { dispatchScheduleTarget, executeSchedule } from "../scheduler/scheduler";
+import { registerDeferTaskTool } from "../tools/defer-task";
+
+type Result = { structuredContent: { success: boolean; message: string; scheduleId?: string } };
+type Tool = {
+  handler: (args: unknown, extra: unknown) => Promise<Result>;
+  inputSchema: { safeParse: (args: unknown) => { success: boolean } };
+};
+const templateGlobals = globalThis as typeof globalThis & { __testMigrationTemplate?: Uint8Array };
+let savedTemplate: Uint8Array | undefined;
+let dir: string;
+let path: string;
+let agentId: string;
+let tool: Tool;
+
+beforeAll(async () => {
+  dir = await mkdtemp(join(tmpdir(), "task-wake-"));
+  path = join(dir, "test.sqlite");
+  // The preload normally deserializes a fresh in-memory DB on every initDb.
+  // Use a real file here so close/reopen verifies durable restart recovery.
+  savedTemplate = templateGlobals.__testMigrationTemplate;
+  if (savedTemplate) await Bun.write(path, savedTemplate);
+  delete templateGlobals.__testMigrationTemplate;
+  initDb(path);
+  agentId = (
+    await createAgent({
+      name: "Wake worker",
+      isLead: false,
+      status: "busy",
+      capabilities: [],
+      maxTasks: 10,
+    })
+  ).id;
+  const server = new McpServer({ name: "wake-test", version: "1.0.0" });
+  registerDeferTaskTool(server);
+  tool = (server as unknown as { _registeredTools: Record<string, Tool> })._registeredTools[
+    "defer-task"
+  ]!;
+});
+afterEach(() => stopDeferredTaskWaits());
+afterAll(async () => {
+  closeDb();
+  templateGlobals.__testMigrationTemplate = savedTemplate;
+  await rm(dir, { recursive: true, force: true });
+});
+
+async function activeTask() {
+  const task = await createTaskExtended("work in progress", {
+    agentId,
+    modelTier: "smart",
+    priority: 70,
+  });
+  await startTask(task.id);
+  return task;
+}
+async function defer(
+  taskId: string,
+  watchedId: string,
+  event: TaskWakeEvent = "settled",
+  extra: Record<string, unknown> = {},
+) {
+  return tool.handler(
+    {
+      taskId,
+      wakeOn: { taskId: watchedId, event },
+      delayMs: 3600000,
+      summary: "Work submitted",
+      note: "Check the producer result",
+      checks: ["verify output"],
+      ...extra,
+    },
+    { sessionId: crypto.randomUUID(), requestInfo: { headers: { "x-agent-id": agentId } } },
+  );
+}
+async function fixture(event: TaskWakeEvent = "settled") {
+  const parent = await activeTask();
+  const producer = await activeTask();
+  const result = await defer(parent.id, producer.id, event);
+  expect(result.structuredContent.success).toBe(true);
+  const schedule = await getScheduledTaskById(result.structuredContent.scheduleId!);
+  return { parent, producer, schedule: schedule! };
+}
+async function children(scheduleId: string) {
+  const rows = await getDbClient().query<{ id: string }>(
+    "SELECT id FROM agent_tasks WHERE scheduleId = ?",
+    [scheduleId],
+  );
+  return Promise.all(rows.map((row) => getTaskById(row.id)));
+}
+async function awaitChild(scheduleId: string) {
+  const deadline = Date.now() + 3000;
+  while (Date.now() < deadline) {
+    const found = await children(scheduleId);
+    if (found.length) return found[0]!;
+    await Bun.sleep(5);
+  }
+  throw new Error("Event bus did not create a wake-up child");
+}
+async function waitState(scheduleId: string) {
+  return getDbClient().get<{
+    taskId: string;
+    status: string;
+    firedBy: string | null;
+    childTaskId: string | null;
+    resolvedAt: string | null;
+    updated_at: string;
+  }>("SELECT * FROM deferred_task_waits WHERE scheduleId = ?", [scheduleId]);
+}
+
+describe("defer-task wakeOn", () => {
+  test("ordinary schedules neither suppress a completion nor retarget its waiters", async () => {
+    const { producer, schedule } = await fixture();
+    const ordinary = await createScheduledTask({
+      name: `ordinary-${crypto.randomUUID()}`,
+      taskTemplate: "Related scheduled work",
+      taskType: "maintenance",
+      intervalMs: 60000,
+      parentTaskId: producer.id,
+    });
+    await dispatchScheduleTarget(ordinary);
+    expect(await waitState(schedule.id)).toMatchObject({ taskId: producer.id, status: "pending" });
+    await completeTask(producer.id, "done");
+    await reconcileDeferredTaskWaits(producer.id);
+    expect(await children(schedule.id)).toHaveLength(1);
+  });
+
+  test("two waiters follow a time-based deferral and fire once on the resume task's completion", async () => {
+    await initDeferredTaskWaits();
+    const { producer, schedule } = await fixture();
+    const second = await defer((await activeTask()).id, producer.id, "task.completed");
+    const secondSchedule = (await getScheduledTaskById(second.structuredContent.scheduleId!))!;
+    const deferred = await defer(producer.id, producer.id, "settled", { wakeOn: undefined });
+    expect(deferred.structuredContent.success).toBe(true);
+    const successor = (await getScheduledTaskById(deferred.structuredContent.scheduleId!))!;
+
+    await reconcileDeferredTaskWaits(producer.id);
+    for (const waiter of [schedule, secondSchedule]) {
+      expect(await children(waiter.id)).toHaveLength(0);
+      expect(await waitState(waiter.id)).toMatchObject({
+        taskId: producer.id,
+        status: "pending",
+        firedBy: null,
+      });
+    }
+
+    await executeSchedule(successor);
+    const resumed = (await children(successor.id))[0]!;
+    for (const waiter of [schedule, secondSchedule]) {
+      expect(await waitState(waiter.id)).toMatchObject({ taskId: resumed.id, status: "pending" });
+      expect((await getScheduledTaskById(waiter.id))?.nextRunAt).toBe(waiter.nextRunAt);
+    }
+    await reconcileDeferredTaskWaits();
+    expect(await children(schedule.id)).toHaveLength(0);
+    await completeTask(resumed.id, "real result");
+    for (const waiter of [schedule, secondSchedule]) {
+      const child = await awaitChild(waiter.id);
+      expect(child.task).toContain(`Wake-up cause: task.completed for task ${resumed.id}`);
+      const fired = await waitState(waiter.id);
+      expect(fired).toMatchObject({
+        status: "fired",
+        firedBy: "task.completed",
+        childTaskId: child.id,
+      });
+      expect(fired?.updated_at).toBe(fired?.resolvedAt);
+      await Promise.all([executeSchedule(waiter), reconcileDeferredTaskWaits(resumed.id)]);
+      expect(await children(waiter.id)).toHaveLength(1);
+      expect(await waitState(waiter.id)).toEqual(fired);
+    }
+  });
+
+  test("event-driven deferrals retarget through a chain without refreshing the waiter's ceiling", async () => {
+    const { producer, schedule } = await fixture("task.failed");
+    let current = producer;
+    for (let step = 0; step < 2; step++) {
+      const dependency = await activeTask();
+      const deferred = await defer(current.id, dependency.id);
+      expect(deferred.structuredContent.success).toBe(true);
+      await reconcileDeferredTaskWaits(current.id);
+      expect(await waitState(schedule.id)).toMatchObject({ taskId: current.id, status: "pending" });
+      await completeTask(dependency.id, "dependency ready");
+      await reconcileDeferredTaskWaits(dependency.id);
+      current = (await children(deferred.structuredContent.scheduleId!))[0]!;
+      expect(await waitState(schedule.id)).toMatchObject({ taskId: current.id, status: "pending" });
+      expect((await getScheduledTaskById(schedule.id))?.nextRunAt).toBe(schedule.nextRunAt);
+    }
+
+    await failTask(current.id, "real failure");
+    // Reopen to verify the new watched task is durable across restarts.
+    closeDb();
+    initDb(path);
+    await initDeferredTaskWaits();
+    const child = await awaitChild(schedule.id);
+    expect(child.task).toContain(`Wake-up cause: task.failed for task ${current.id}`);
+    expect(await children(schedule.id)).toHaveLength(1);
+  });
+
+  test("the original ceiling still fires during the defer gap and fired waits never retarget", async () => {
+    const { producer, schedule } = await fixture();
+    const deferred = await defer(producer.id, producer.id, "settled", { wakeOn: undefined });
+    const successor = (await getScheduledTaskById(deferred.structuredContent.scheduleId!))!;
+    await reconcileDeferredTaskWaits(producer.id);
+    expect(await children(schedule.id)).toHaveLength(0);
+    expect((await getScheduledTaskById(schedule.id))?.nextRunAt).toBe(schedule.nextRunAt);
+    await executeSchedule(schedule);
+    const fired = await waitState(schedule.id);
+    expect(fired).toMatchObject({ taskId: producer.id, firedBy: "ceiling", status: "fired" });
+    expect(fired?.updated_at).toBe(fired?.resolvedAt);
+    await executeSchedule(successor);
+    const resumed = (await children(successor.id))[0]!;
+    await completeTask(resumed.id, "late result");
+    await reconcileDeferredTaskWaits();
+    expect(await waitState(schedule.id)).toEqual(fired);
+    expect(await children(schedule.id)).toHaveLength(1);
+  });
+
+  test.each([
+    "disabled",
+    "deleted",
+  ])("a successor schedule that is %s during the gap releases the parent's completion", async (action) => {
+    const { producer, schedule } = await fixture();
+    const deferred = await defer(producer.id, producer.id, "settled", { wakeOn: undefined });
+    const successorId = deferred.structuredContent.scheduleId!;
+    await reconcileDeferredTaskWaits(producer.id);
+    expect(await children(schedule.id)).toHaveLength(0);
+    if (action === "disabled") await updateScheduledTask(successorId, { enabled: false });
+    else await deleteScheduledTask(successorId);
+    await reconcileDeferredTaskWaits();
+    expect(await children(schedule.id)).toHaveLength(1);
+    expect(await waitState(schedule.id)).toMatchObject({
+      taskId: producer.id,
+      status: "fired",
+      firedBy: "task.completed",
+    });
+  });
+
+  test("schema output stays verbatim while a task event wakes the continuation", async () => {
+    const parent = await createTaskExtended("structured deferral", {
+      agentId,
+      outputSchema: { type: "string" },
+    });
+    await startTask(parent.id);
+    const producer = await activeTask();
+
+    for (const output of [undefined, "not JSON", "42"]) {
+      const result = await defer(parent.id, producer.id, "settled", { output });
+      expect(result.structuredContent.success).toBe(false);
+      expect((await getTaskById(parent.id))?.status).toBe("in_progress");
+      expect(
+        await getDbClient().query("SELECT id FROM scheduled_tasks WHERE parentTaskId = ?", [
+          parent.id,
+        ]),
+      ).toHaveLength(0);
+    }
+
+    const output = ' "deploy pending"\n';
+    const result = await defer(parent.id, producer.id, "settled", { output });
+    expect(result.structuredContent.success).toBe(true);
+    expect((await getTaskById(parent.id))?.output).toBe(output);
+    const scheduleId = result.structuredContent.scheduleId!;
+    const logs = (await getLogsByTaskId(parent.id)).filter(
+      (log) => log.eventType === "task_progress",
+    );
+    expect(logs).toHaveLength(1);
+    expect(logs[0]!.newValue).toContain("Work submitted");
+    expect(logs[0]!.newValue).toContain(scheduleId);
+
+    await completeTask(producer.id, "ready");
+    await reconcileDeferredTaskWaits(producer.id);
+    const found = await children(scheduleId);
+    expect(found).toHaveLength(1);
+    expect(found[0]!.parentTaskId).toBe(parent.id);
+    expect(found[0]!.task).toContain("Wake-up cause: task.completed");
+    expect((await getTaskById(parent.id))?.output).toBe(output);
+  });
+
+  test("event fires first: completion bus wakes the normal child and consumes the ceiling", async () => {
+    await initDeferredTaskWaits();
+    const { parent, producer, schedule } = await fixture("task.completed");
+    await completeTask(producer.id, "ready");
+    const child = await awaitChild(schedule.id);
+    expect(child.parentTaskId).toBe(parent.id);
+    expect(child.agentId).toBe(agentId);
+    expect(child.modelTier).toBe("smart");
+    expect(child.model).toBeUndefined();
+    expect(child.priority).toBe(70);
+    expect(child.taskType).toBe("deferred");
+    expect(child.task).toContain(`Resume task ${parent.id}: Check the producer result`);
+    expect(child.task).toContain("- verify output");
+    expect(child.task).toContain(`Wake-up cause: task.completed for task ${producer.id}`);
+    expect((await getScheduledTaskById(schedule.id))?.enabled).toBe(false);
+    await executeSchedule(schedule); // stale poller snapshot after event dispatch
+    await reconcileDeferredTaskWaits();
+    expect(await children(schedule.id)).toHaveLength(1);
+  });
+
+  test("ceiling fires first: later task failure cannot create a second child", async () => {
+    await initDeferredTaskWaits();
+    const { producer, schedule } = await fixture();
+    await executeSchedule(schedule);
+    await failTask(producer.id, "failed later");
+    await reconcileDeferredTaskWaits();
+    const found = await children(schedule.id);
+    expect(found).toHaveLength(1);
+    expect(found[0]?.task).toContain("Wake-up cause: ceiling expired");
+  });
+
+  test("both race: event and ceiling dispatch commit exactly one child", async () => {
+    const { producer, schedule } = await fixture();
+    await completeTask(producer.id, "done");
+    await Promise.all([
+      reconcileDeferredTaskWaits(producer.id),
+      executeSchedule(schedule),
+      dispatchScheduleTarget(schedule),
+      reconcileDeferredTaskWaits(producer.id),
+    ]);
+    const found = await children(schedule.id);
+    expect(found).toHaveLength(1);
+    const wait = await getDbClient().get<{ childTaskId: string; status: string }>(
+      "SELECT childTaskId, status FROM deferred_task_waits WHERE scheduleId = ?",
+      [schedule.id],
+    );
+    expect(wait?.childTaskId).toBe(found[0]!.id);
+    expect(wait?.status).toBe("fired");
+    expect((await getScheduledTaskById(schedule.id))?.nextRunAt).toBeUndefined();
+  });
+
+  test("restart mid-wait: persisted waits regain listeners and catch events missed while stopped", async () => {
+    const live = await fixture("task.failed");
+    const missed = await fixture("settled");
+    stopDeferredTaskWaits();
+    await completeTask(missed.producer.id, "completed while listener was down");
+    closeDb();
+    initDb(path);
+    await initDeferredTaskWaits();
+    expect(await children(missed.schedule.id)).toHaveLength(1);
+    expect(await children(live.schedule.id)).toHaveLength(0);
+    await failTask(live.producer.id, "failed after restart");
+    expect((await awaitChild(live.schedule.id)).task).toContain("Wake-up cause: task.failed");
+    await initDeferredTaskWaits();
+    expect(await children(missed.schedule.id)).toHaveLength(1);
+    expect(await children(live.schedule.id)).toHaveLength(1);
+  });
+
+  test("failed child creation rolls back the claim and preserves the ceiling for retry", async () => {
+    const { producer, schedule } = await fixture();
+    await completeTask(producer.id, "done");
+    await updateScheduledTask(schedule.id, { taskTemplate: "" });
+    await expect(dispatchDeferredTaskWait(schedule.id, "task.completed")).rejects.toThrow(
+      "no taskTemplate",
+    );
+    expect(
+      (
+        await getDbClient().get<{ status: string }>(
+          "SELECT status FROM deferred_task_waits WHERE scheduleId = ?",
+          [schedule.id],
+        )
+      )?.status,
+    ).toBe("pending");
+    expect((await getScheduledTaskById(schedule.id))?.enabled).toBe(true);
+    expect(await children(schedule.id)).toHaveLength(0);
+    await updateScheduledTask(schedule.id, { taskTemplate: schedule.taskTemplate });
+    await executeSchedule(schedule);
+    expect(await children(schedule.id)).toHaveLength(1);
+  });
+
+  test("unmatched task or event does not wake; cancelled producer still has a ceiling", async () => {
+    await initDeferredTaskWaits();
+    const { producer, schedule } = await fixture("task.completed");
+    const other = await activeTask();
+    await completeTask(other.id, "unrelated");
+    await failTask(producer.id, "wrong event");
+    await reconcileDeferredTaskWaits();
+    expect(await children(schedule.id)).toHaveLength(0);
+    const cancelled = await fixture();
+    await cancelTask(cancelled.producer.id, "cancelled");
+    await reconcileDeferredTaskWaits();
+    expect(await children(cancelled.schedule.id)).toHaveLength(0);
+    await executeSchedule(cancelled.schedule);
+    expect(await children(cancelled.schedule.id)).toHaveLength(1);
+    await executeSchedule(schedule);
+  });
+
+  test("already terminal, missing, and self-watched tasks reject without completing the parent", async () => {
+    const parent = await activeTask();
+    const producer = await activeTask();
+    await completeTask(producer.id, "already done");
+    for (const [id, message] of [
+      [producer.id, "already completed"],
+      [crypto.randomUUID(), "not found"],
+      [parent.id, "Cannot wake on"],
+    ]) {
+      const result = await defer(parent.id, id!);
+      expect(result.structuredContent.success).toBe(false);
+      expect(result.structuredContent.message).toContain(message!);
+    }
+    expect((await getTaskById(parent.id))?.status).toBe("in_progress");
+    expect(
+      await getDbClient().query("SELECT id FROM scheduled_tasks WHERE parentTaskId = ?", [
+        parent.id,
+      ]),
+    ).toHaveLength(0);
+  });
+
+  test("wakeOn requires exactly one ceiling and schema permits only task event sources", async () => {
+    const parent = await activeTask();
+    const producer = await activeTask();
+    for (const extra of [
+      { delayMs: undefined },
+      { runAt: new Date(Date.now() + 60000).toISOString() },
+    ]) {
+      expect(
+        (await defer(parent.id, producer.id, "settled", extra)).structuredContent.success,
+      ).toBe(false);
+    }
+    const base = { taskId: parent.id, summary: "done", note: "wait", delayMs: 60000 };
+    expect(
+      tool.inputSchema.safeParse({
+        ...base,
+        wakeOn: { taskId: producer.id, event: "checks.completed" },
+      }).success,
+    ).toBe(false);
+    expect(
+      tool.inputSchema.safeParse({ ...base, wakeOn: { taskId: producer.id, event: "settled" } })
+        .success,
+    ).toBe(true);
+  });
+});

package/src/tests/heartbeat-reroute-decision.test.ts

@@ -453,6 +453,7 @@ describe("Heartbeat — reroute-decision fallback (DES-523)", () => {
       {
         task: "Resume the crashed work on B",
         agentId: agentB.id,
+        routingReason: "reroute_fault",
         taskType: "resume",
         parentTaskId: original.id,
         allowDuplicate: true,