@desplega.ai/agent-swarm 2.7.4 → 2.7.6

package/src/tests/tasks-readable-row.test.ts

@@ -0,0 +1,155 @@
+import { afterAll, beforeAll, describe, expect, spyOn, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { closeDb, getAllTasks, getDb, getDbClient, initDb } from "../be/db";
+import { readableSessionCondition } from "../be/db/tasks/read";
+
+const TEST_DB_PATH = "./test-tasks-readable-row.sqlite";
+const AT = "2026-10-01T00:00:00.000Z";
+
+async function removeDbFiles(): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"])
+    await unlink(`${TEST_DB_PATH}${suffix}`).catch(() => undefined);
+}
+
+async function task(
+  id: string,
+  opts: { parent?: string; owner?: string; scheduleId?: string } = {},
+): Promise<void> {
+  await getDbClient().run(
+    `INSERT INTO agent_tasks (id, task, status, source, parentTaskId, requestedByUserId, scheduleId,
+       createdAt, lastUpdatedAt)
+     VALUES (?, ?, 'completed', 'api', ?, ?, ?, ?, ?)`,
+    [id, `task ${id}`, opts.parent ?? null, opts.owner ?? null, opts.scheduleId ?? null, AT, AT],
+  );
+}
+
+describe("readableSessionRowCondition", () => {
+  beforeAll(async () => {
+    await removeDbFiles();
+    initDb(TEST_DB_PATH);
+    for (const id of ["u1", "u2", "u3"]) {
+      await getDbClient().run(
+        "INSERT INTO users (id, name, role, status, createdAt, lastUpdatedAt) VALUES (?, ?, 'member', 'active', ?, ?)",
+        [id, id, AT, AT],
+      );
+    }
+    // u1's session, three deep.
+    await task("a", { owner: "u1" });
+    await task("a1", { parent: "a", owner: "u1" });
+    await task("a2", { parent: "a1" });
+    // u2's session, with a child that names u1.
+    await task("b", { owner: "u2" });
+    await task("b1", { parent: "b", owner: "u1" });
+    // u2's schedule run: everyone reads it.
+    await task("c", { owner: "u2", scheduleId: "schedule-1" });
+    await task("c1", { parent: "c" });
+    // u2's session shared with u1, and one shared with everyone.
+    await task("d", { owner: "u2" });
+    await task("d1", { parent: "d" });
+    await task("e", { owner: "u2" });
+    await getDbClient().run(
+      `INSERT INTO session_shares (id, rootTaskId, userId, access, createdAt)
+       VALUES ('share-d', 'd', 'u1', 'read', ?), ('share-e', 'e', NULL, 'read', ?)`,
+      [AT, AT],
+    );
+    // A revoked share hides again.
+    await task("f", { owner: "u2" });
+    await getDbClient().run(
+      `INSERT INTO session_shares (id, rootTaskId, userId, access, createdAt, revokedAt)
+       VALUES ('share-f', 'f', 'u1', 'read', ?, ?)`,
+      [AT, AT],
+    );
+    // A session nobody owns.
+    await task("g");
+    await task("g1", { parent: "g", owner: "u2" });
+    // Orphan subtrees: the top's parent is gone, so the top is the root.
+    await task("h", { owner: "u2" });
+    await task("h1", { parent: "h" });
+    await task("h2", { parent: "h1", owner: "u1" });
+    await task("i", { owner: "u1" });
+    await task("i1", { parent: "i", owner: "u2" });
+    await task("i2", { parent: "i1" });
+    // Chains deeper than the walk's hop limit fall back to the set form.
+    for (const [root, owner] of [
+      ["deep-u1", "u1"],
+      ["deep-u2", "u2"],
+    ] as const) {
+      await task(root, { owner });
+      let parent: string = root;
+      for (let i = 1; i <= 70; i++) {
+        await task(`${root}-${i}`, { parent });
+        parent = `${root}-${i}`;
+      }
+    }
+    getDb().run("PRAGMA foreign_keys = OFF");
+    getDb().run("DELETE FROM agent_tasks WHERE id IN ('h', 'i')");
+    getDb().run("PRAGMA foreign_keys = ON");
+  });
+
+  afterAll(async () => {
+    closeDb();
+    await removeDbFiles();
+  });
+
+  for (const userId of ["u1", "u2", "u3", null]) {
+    test(`the page shows the rows the set form shows, for ${userId ?? "a guest"}`, async () => {
+      const set = readableSessionCondition(userId);
+      const expected = (
+        await getDbClient().query<{ id: string }>(
+          `SELECT id FROM agent_tasks WHERE ${set.sql} ORDER BY id`,
+          set.params,
+        )
+      ).map((row) => row.id);
+      const page = await getAllTasks({ readableBy: { userId }, limit: 1000 });
+      expect(page.map((t) => t.id).sort()).toEqual(expected);
+    });
+  }
+
+  test("u1 sees exactly the expected sessions", async () => {
+    const page = await getAllTasks({ readableBy: { userId: "u1" }, limit: 1000 });
+    const deep = Array.from({ length: 70 }, (_, i) => `deep-u1-${i + 1}`);
+    expect(page.map((t) => t.id).sort()).toEqual(
+      [
+        "a",
+        "a1",
+        "a2",
+        "c",
+        "c1",
+        "d",
+        "d1",
+        "e",
+        "g",
+        "g1",
+        "h1",
+        "h2",
+        "deep-u1",
+        ...deep,
+      ].sort(),
+    );
+  });
+
+  test("the page walks up from each row it reads", async () => {
+    const query = spyOn(getDbClient(), "query");
+    let sql = "";
+    let params: unknown[] = [];
+    try {
+      await getAllTasks({ status: "completed", readableBy: { userId: "u1" } });
+      [sql, params = []] = query.mock.calls.find(([s]) => s.includes("WITH page AS"))! as [
+        string,
+        unknown[]?,
+      ];
+    } finally {
+      query.mockRestore();
+    }
+    const plan = getDb()
+      .query<{ detail: string }, any[]>(`EXPLAIN QUERY PLAN ${sql}`)
+      .all(...(params as any[]))
+      .map((row) => row.detail)
+      .join("\n");
+    // The walk is a correlated lookup per row. The set form appears only as
+    // the fallback branch, which SQLite builds when a walk finds no root.
+    expect(plan).toContain("CORRELATED SCALAR SUBQUERY");
+    expect(plan).toContain("SEARCH u USING INDEX sqlite_autoindex_agent_tasks_1 (id=?)");
+    expect(plan).toContain("SEARCH p USING INDEX sqlite_autoindex_agent_tasks_1 (id=?)");
+  });
+});

package/src/tests/tool-annotations.test.ts

@@ -181,6 +181,7 @@ describe("Tool Annotations & Classification", () => {
       "slack-list-channels",
       "slack-delete",
       "slack-update",
+      "slack-leave-thread",
     ];
 
     for (const name of slackTools) {
@@ -379,7 +380,7 @@ describe("Tool Annotations & Classification", () => {
     // the six Chat SDK tools (chat-* + register/unregister-chat-channel),
     // and the seven app row tools plus app-action-run.
     expect(count).toBeGreaterThanOrEqual(45);
-    expect(count).toBeLessThanOrEqual(169);
+    expect(count).toBeLessThanOrEqual(170);
   });
 
   test("core tools are fewer than deferred tools", () => {

package/src/tests/workflow-engine-v2.test.ts

@@ -945,6 +945,48 @@ describe("Workflow Engine v2 (Phase 3)", () => {
       expect(run2!.status).toBe("skipped");
       expect(run2!.error).toBe("cooldown");
     });
+
+    test("simultaneous triggers start one run; the other records a cooldown skip", async () => {
+      const registry = createTestRegistry();
+      const def: WorkflowDefinition = {
+        nodes: [{ id: "a", type: "echo", config: { message: "hi" } }],
+      };
+      const workflow = await makeWorkflow(def, { cooldown: { hours: 20, from: "start" } });
+
+      // Both pass the pre-transaction check before either run row exists.
+      const runIds = await Promise.all([
+        startWorkflowExecution(workflow, {}, registry),
+        startWorkflowExecution(workflow, {}, registry),
+      ]);
+      const statuses = await Promise.all(
+        runIds.map(async (id) => (await getWorkflowRun(id))!.status),
+      );
+      expect(statuses.sort()).toEqual(["completed", "skipped"]);
+    });
+
+    test('from: "start" ignores a long successful run that finished inside the window', async () => {
+      const { createWorkflowRun, updateWorkflowRun } = await import("../be/db");
+      const def: WorkflowDefinition = {
+        nodes: [{ id: "a", type: "echo", config: {} }],
+      };
+      const workflow = await makeWorkflow(def);
+
+      // Started 24h ago, finished 1h ago: 24h since its start, 1h since its finish.
+      const runId = crypto.randomUUID();
+      await createWorkflowRun({ id: runId, workflowId: workflow.id });
+      await getDbClient().run("UPDATE workflow_runs SET startedAt = ? WHERE id = ?", [
+        new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString(),
+        runId,
+      ]);
+      await updateWorkflowRun(runId, {
+        status: "completed",
+        finishedAt: new Date(Date.now() - 60 * 60 * 1000).toISOString(),
+      });
+
+      expect(await shouldSkipCooldown(workflow.id, { hours: 20, from: "start" })).toBe(false);
+      // Control: the default also counts from the successful finish.
+      expect(await shouldSkipCooldown(workflow.id, { hours: 20 })).toBe(true);
+    });
   });
 
   // ─── Input Resolution ─────────────────────────────────────

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

@@ -13,14 +13,19 @@ import {
   createAgent,
   createScheduledTask,
   createWorkflow,
+  createWorkflowRun,
   getDbClient,
+  getScheduledTaskByName,
+  getWorkflowRun,
   initDb,
   listWorkflows,
+  updateWorkflow,
 } from "../be/db";
 import { upsertScriptByName } from "../be/scripts/db";
 import { setScriptEmbeddingProviderForTests } from "../be/scripts/embeddings";
 import * as runCredential from "../be/scripts/run-credential";
 import { runSeeder } from "../be/seed";
+import { createSchedulesSeeder } from "../be/seed/schedules-seeder";
 import { createWorkflowsSeeder } from "../be/seed/workflows-seeder";
 import { getPathSegments, parseQueryParams } from "../http/utils";
 import { handleWorkflows } from "../http/workflows";
@@ -34,6 +39,7 @@ import {
   workflowEventBus,
 } from "../workflows";
 import { handleEventTrigger } from "../workflows/triggers";
+import { snapshotAndUpdateWorkflow } from "../workflows/version";
 import { listenOnFreePort } from "./test-net";
 
 // A creator-less workflow (the seeded `dreaming`) runs its `swarm-script` nodes as
@@ -160,9 +166,31 @@ afterAll(async () => {
   await removeDbFiles();
 });
 
-beforeEach(() => {
-  // Dreaming has no cooldown, so earlier runs (parked on an agent-task) do not
-  // block the next trigger.
+/** Put the seeded dreaming row back after a test edits it. */
+async function restoreDreaming(): Promise<void> {
+  await updateWorkflow(dreaming.id, {
+    description: dreaming.description,
+    definition: dreaming.definition,
+    input: dreaming.input,
+    cooldown: dreaming.cooldown,
+    enabled: dreaming.enabled,
+  });
+}
+
+/** Move every dreaming run start out of its 20-hour cooldown window. */
+async function ageDreamingRuns(): Promise<void> {
+  await getDbClient().run(
+    `UPDATE workflow_runs SET startedAt = '2000-01-01T00:00:00.000Z',
+       finishedAt = CASE WHEN finishedAt IS NULL THEN NULL ELSE '2000-01-01T00:00:00.000Z' END
+     WHERE workflowId = ?`,
+    [dreaming.id],
+  );
+}
+
+beforeEach(async () => {
+  // Dreaming has a 20-hour cooldown. Age earlier runs (parked on an agent-task)
+  // so they do not block the next trigger.
+  await ageDreamingRuns();
   calls = [];
   scriptResult = QUIET_GATHER;
 });
@@ -241,6 +269,179 @@ describe("swarm-script principal for a creator-less workflow", () => {
     expect(gatherPrincipals()).toEqual([leadId]);
   });
 
+  test("a creator-less schedule runs as the lead, resolved at fire time", async () => {
+    const schedule = await createScheduledTask({
+      name: `principal-seeded-${crypto.randomUUID().slice(0, 8)}`,
+      cronExpression: "0 0 1 1 *",
+      targetType: "workflow",
+      workflowId: dreaming.id,
+      targetAgentId: workerId,
+    });
+    expect(schedule.createdByAgentId).toBeUndefined();
+    await dispatchScheduleTarget(schedule);
+    expect(gatherPrincipals()).toEqual([leadId]);
+  });
+
+  test("a creator-less schedule fails its fire when the swarm has no lead", async () => {
+    const schedule = await createScheduledTask({
+      name: `principal-leadless-${crypto.randomUUID().slice(0, 8)}`,
+      cronExpression: "0 0 1 1 *",
+      targetType: "workflow",
+      workflowId: dreaming.id,
+    });
+    await getDbClient().run("UPDATE agents SET isLead = 0 WHERE id = ?", [leadId]);
+    try {
+      await expect(dispatchScheduleTarget(schedule)).rejects.toThrow(
+        "has no creator and the swarm has no lead",
+      );
+    } finally {
+      await getDbClient().run("UPDATE agents SET isLead = 1 WHERE id = ?", [leadId]);
+    }
+    expect(calls).toEqual([]);
+    const runs = await getDbClient().query<{ id: string }>(
+      "SELECT id FROM workflow_runs WHERE workflowId = ? AND startedAt > '2001-01-01'",
+      [dreaming.id],
+    );
+    expect(runs).toEqual([]);
+  });
+
+  test("a creator-less schedule keeps the lead after the documented input setup and enable", async () => {
+    // The guide's setup: update-workflow with every input key, then turn it on.
+    // Both snapshot the seeded state first, as the tool and REST paths do.
+    await snapshotAndUpdateWorkflow(
+      dreaming.id,
+      { input: { ...dreaming.input, leadAgentId: leadId, slackChannel: "C123" } },
+      { changedByAgentId: workerId },
+    );
+    await snapshotAndUpdateWorkflow(dreaming.id, { enabled: false });
+    await snapshotAndUpdateWorkflow(dreaming.id, {
+      enabled: true,
+      description: "tuned by the operator",
+      cooldown: { hours: 22, from: "start" },
+    });
+    const schedule = await createScheduledTask({
+      name: `principal-tuned-${crypto.randomUUID().slice(0, 8)}`,
+      cronExpression: "0 0 1 1 *",
+      targetType: "workflow",
+      workflowId: dreaming.id,
+    });
+    try {
+      await dispatchScheduleTarget(schedule);
+      expect(gatherPrincipals()).toEqual([leadId]);
+      expect(calls[0]?.args.leadAgentId).toBe(leadId);
+    } finally {
+      await restoreDreaming();
+    }
+  });
+
+  test("a creator-less schedule refuses the lead once a worker edits the seeded nodes", async () => {
+    const schedule = await createScheduledTask({
+      name: `principal-edited-${crypto.randomUUID().slice(0, 8)}`,
+      cronExpression: "0 0 1 1 *",
+      targetType: "workflow",
+      workflowId: dreaming.id,
+    });
+    const [gather, ...rest] = dreaming.definition.nodes;
+    await snapshotAndUpdateWorkflow(
+      dreaming.id,
+      {
+        input: { ...dreaming.input, leadAgentId: leadId },
+        definition: {
+          ...dreaming.definition,
+          nodes: [{ ...gather!, config: { ...gather!.config, scriptName: "evil" } }, ...rest],
+        },
+      },
+      { changedByAgentId: workerId },
+    );
+    try {
+      await expect(dispatchScheduleTarget(schedule)).rejects.toThrow(
+        'the nodes or params of seeded workflow "dreaming" were edited',
+      );
+    } finally {
+      await restoreDreaming();
+    }
+    expect(calls).toEqual([]);
+  });
+
+  test("a creator-less schedule refuses the lead for an edit with no seeded snapshot", async () => {
+    const schedule = await createScheduledTask({
+      name: `principal-unsnapshotted-${crypto.randomUUID().slice(0, 8)}`,
+      cronExpression: "0 0 1 1 *",
+      targetType: "workflow",
+      workflowId: dreaming.id,
+    });
+    // Delete the history so no snapshot proves the seeded state.
+    await getDbClient().run("DELETE FROM workflow_versions WHERE workflowId = ?", [dreaming.id]);
+    await updateWorkflow(dreaming.id, { description: "edited without a snapshot" });
+    try {
+      await expect(dispatchScheduleTarget(schedule)).rejects.toThrow("were edited");
+    } finally {
+      await restoreDreaming();
+    }
+    expect(calls).toEqual([]);
+  });
+
+  test("a long successful night does not make the next nightly fire skip", async () => {
+    const schedule = await createScheduledTask({
+      name: `principal-long-${crypto.randomUUID().slice(0, 8)}`,
+      cronExpression: "0 0 1 1 *",
+      targetType: "workflow",
+      workflowId: dreaming.id,
+    });
+    // Last night started 24h ago and finished 1h ago.
+    const runId = crypto.randomUUID();
+    await createWorkflowRun({ id: runId, workflowId: dreaming.id });
+    await getDbClient().run(
+      "UPDATE workflow_runs SET status = 'completed', startedAt = ?, finishedAt = ? WHERE id = ?",
+      [
+        new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString(),
+        new Date(Date.now() - 60 * 60 * 1000).toISOString(),
+        runId,
+      ],
+    );
+    const fired = await dispatchScheduleTarget(schedule);
+    const run = await getWorkflowRun(fired.workflowRunIds![0]!);
+    expect(run?.status).not.toBe("skipped");
+    expect(gatherPrincipals()).toEqual([leadId]);
+  });
+
+  test("control: a creator-less workflow the seeder never wrote keeps running agentless", async () => {
+    const copy = await createWorkflow({
+      name: `principal-unseeded-${crypto.randomUUID()}`,
+      definition: dreaming.definition,
+    });
+    const schedule = await createScheduledTask({
+      name: `principal-unseeded-${crypto.randomUUID().slice(0, 8)}`,
+      cronExpression: "0 0 1 1 *",
+      targetType: "workflow",
+      workflowId: copy.id,
+    });
+    await dispatchScheduleTarget(schedule);
+    expect(gatherPrincipals()).toEqual(["workflow"]);
+  });
+
+  test("end to end: the seeded dreaming-daily schedule fires dreaming as the lead, once a day", async () => {
+    const seeded = await runSeeder(createSchedulesSeeder(), { quiet: true });
+    expect(seeded.failed).toEqual([]);
+    const schedule = await getScheduledTaskByName("dreaming-daily");
+    expect(schedule).toMatchObject({ targetType: "workflow", workflowId: dreaming.id });
+    expect(schedule?.taskTemplate).toBeUndefined();
+    expect(schedule?.createdByAgentId).toBeUndefined();
+
+    const first = await dispatchScheduleTarget(schedule!);
+    expect(first.task).toBeUndefined();
+    expect(first.workflowRunIds).toHaveLength(1);
+    expect(gatherPrincipals()).toEqual([leadId]);
+    const run = await getWorkflowRun(first.workflowRunIds![0]!);
+    expect(run?.triggerData).toMatchObject({ scheduleName: "dreaming-daily" });
+
+    // The cooldown replaces the old task prompt's 20-hour double-run guard.
+    const second = await dispatchScheduleTarget(schedule!);
+    const skipped = await getWorkflowRun(second.workflowRunIds![0]!);
+    expect(skipped).toMatchObject({ status: "skipped", error: "cooldown" });
+    expect(gatherPrincipals()).toEqual([leadId]);
+  });
+
   test("control: a workflow with a creator still runs as its creator", async () => {
     const owned = await createWorkflow({
       name: `principal-owned-${crypto.randomUUID()}`,
@@ -251,10 +452,9 @@ describe("swarm-script principal for a creator-less workflow", () => {
     expect(gatherPrincipals()).toEqual([leadId]);
   });
 
-  test("control: the seeded schedule's fire (a worker triggers with no data) runs the *-lead nodes on the lead", async () => {
-    // dreaming-daily makes a pool task; the worker that claims it calls
-    // trigger-workflow with no triggerData. Scripts run as that worker, while
-    // synthesize and apply-lead target gather's leadAgentId.
+  test("control: a worker's manual trigger with no data runs the *-lead nodes on the lead", async () => {
+    // A worker that calls trigger-workflow with no triggerData. Scripts run as
+    // that worker, while synthesize and apply-lead target gather's leadAgentId.
     scriptResult = {
       ok: true,
       agents: [{ id: workerId, name: "principal-worker" }],

package/src/tools/send-task.ts

@@ -5,9 +5,7 @@ import { resolveTaskAuditUserId } from "@/be/audit-user";
 import {
   createTaskExtended,
   extensionAgentAssignmentError,
-  findCompletedTaskInThread,
   findExistingLinearTrackerContextWork,
-  findRecentCancelledTaskInThread,
   getActiveTaskCount,
   getAgentById,
   getDbClient,
@@ -23,6 +21,10 @@ import { repointTrackerSyncBySwarmId } from "@/be/db-queries/tracker";
 import { explicitModelErrorForAgent } from "@/be/model-validation";
 import { applyPreTaskCreate } from "@/extensions/apply-task-create";
 import { can } from "@/rbac";
+import {
+  evaluateFollowUpRedelegation,
+  followUpThreadForSourceTask,
+} from "@/tasks/follow-up-redelegation-guard";
 import { checkSlackRoutingCoherence } from "@/tasks/slack-routing";
 import { findDuplicateTask } from "@/tools/task-dedup";
 import { ownerCtx, type ToolCtx } from "@/tools/task-tool-ctx";
@@ -163,7 +165,13 @@ export const sendTaskInputSchema = z
       .boolean()
       .default(false)
       .describe(
-        "If true, skip duplicate detection and create the task even if a similar one exists.",
+        "If true, skip duplicate detection and create the task even if a similar one exists. Does not bypass the follow-up re-delegation guard; see allowRedelegation.",
+      ),
+    allowRedelegation: z
+      .boolean()
+      .default(false)
+      .describe(
+        "Only matters when you call send-task from a follow-up task in a Slack thread. Such a dispatch is blocked when it repeats a task already completed in that thread (same-work rule, unless a task there was cancelled or failed after that completion), or when you already dispatched 10 tasks into the thread in the last 6 hours (loop-cap rule). Set true to dispatch anyway; the override is logged. Use it only for deliberate re-runs or long chains, never to retry a block you have not read.",
       ),
     slackChannelId: z
       .string()
@@ -292,6 +300,7 @@ export async function sendTaskHandler(
     effort,
     profile,
     allowDuplicate,
+    allowRedelegation,
     slackChannelId,
     slackThreadTs,
     slackUserId,
@@ -316,6 +325,7 @@ export async function sendTaskHandler(
   const requestedLeadOnly = ctx.kind === "user" ? false : leadOnly;
   const requestedCapabilities = ctx.kind === "user" ? undefined : requiredCapabilities;
   const requestedAllowDuplicate = ctx.kind === "user" ? false : allowDuplicate;
+  const requestedAllowRedelegation = ctx.kind === "user" ? false : allowRedelegation;
   const requestedOverrideSlackContext = ctx.kind === "user" ? false : overrideSlackContext;
 
   // Defense in depth for direct TypeScript callers that bypass MCP schema parsing.
@@ -572,7 +582,9 @@ export async function sendTaskHandler(
   // Every read in this handler releases the FIFO lock, so two concurrent
   // send-task calls with the same creator and text otherwise both pass the
   // guards and both create a task (no UNIQUE index arbitrates them).
-  const evaluateDedupGuards = async (): Promise<{
+  const evaluateDedupGuards = async (
+    logOverride: boolean,
+  ): Promise<{
     ok: boolean;
     message: string;
     task?: AgentTask;
@@ -602,59 +614,35 @@ export async function sendTaskHandler(
       }
     }
 
-    // Guard: prevent re-delegation from follow-up tasks
-    // When the source task is a "follow-up" (worker completed/failed notification),
-    // check if there are completed tasks in the same Slack thread recently.
-    // This prevents the cycle: worker completes → follow-up → Lead re-delegates → repeat.
-    //
-    // Exception: if a MORE RECENT task in the same thread was cancelled (exit 130,
-    // status='cancelled', or status='failed' with failureReason containing
-    // "cancelled"), bypass the guard. A cancellation means the work was
-    // interrupted — re-dispatch is the correct response, not a deduped no-op.
-    // Without this bypass, a cancelled worker permanently jams the thread
-    // against re-delegation when an earlier completed sibling exists.
+    // Guard: prevent re-delegation from follow-up tasks (same-work and
+    // loop-cap rules, see src/tasks/follow-up-redelegation-guard.ts).
+    // allowRedelegation bypasses both and is logged.
     //
     // NOTE: `taskType === "resume"` (created by createResumeFollowUp on
     // supersede) is intentionally NOT in this guard — a resume IS the legitimate
     // re-dispatch and bypassing the check is correct. Do not add "resume" here.
-    if (sourceTaskId) {
-      const sourceTask = await getTaskById(sourceTaskId);
-      if (
-        sourceTask?.taskType === "follow-up" &&
-        sourceTask.slackThreadTs &&
-        sourceTask.slackChannelId
-      ) {
-        const recentCompleted = await findCompletedTaskInThread(
-          sourceTask.slackChannelId,
-          sourceTask.slackThreadTs,
-          2880, // 48 hours in minutes
+    const followUpThread = creatorAgentId ? await followUpThreadForSourceTask(sourceTaskId) : null;
+    if (followUpThread && creatorAgentId) {
+      const blocked = await evaluateFollowUpRedelegation({
+        ...followUpThread,
+        creatorAgentId,
+        taskDescription,
+        targetAgentId: taskOptions.agentId ?? taskOptions.offeredTo,
+      });
+      if (blocked && !requestedAllowRedelegation) {
+        return { ok: false, message: blocked.message };
+      }
+      if (blocked && logOverride) {
+        console.log(
+          `[send-task] follow-up re-delegation override: rule=${blocked.rule} creatorAgentId=${creatorAgentId} sourceTaskId=${sourceTaskId} thread=${followUpThread.channelId}/${followUpThread.threadTs}`,
         );
-        if (recentCompleted) {
-          const recentCancelled = await findRecentCancelledTaskInThread(
-            sourceTask.slackChannelId,
-            sourceTask.slackThreadTs,
-            2880,
-          );
-          const cancelledMoreRecent =
-            recentCancelled &&
-            new Date(recentCancelled.lastUpdatedAt).getTime() >
-              new Date(recentCompleted.lastUpdatedAt).getTime();
-          if (!cancelledMoreRecent) {
-            return {
-              ok: false,
-              message: `Blocked: re-delegation from follow-up task in a thread that already has completed work (task ${recentCompleted.id.slice(0, 8)}). The original request was already handled.`,
-            };
-          }
-          // else: fall through — the cancellation is more recent than the
-          // completion, so re-delegation is legitimate.
-        }
       }
     }
 
     return null;
   };
 
-  const guard = await evaluateDedupGuards();
+  const guard = await evaluateDedupGuards(true);
   if (guard) {
     const guardData = {
       yourAgentId: creatorAgentId,
@@ -669,7 +657,7 @@ export async function sendTaskHandler(
     // Authoritative re-check: the reads above are separated from the INSERT by
     // the whole handler, so only a guard inside this transaction can see a
     // concurrent send-task's committed task.
-    const raced = await evaluateDedupGuards();
+    const raced = await evaluateDedupGuards(false);
     if (raced) return { success: raced.ok, message: raced.message, task: raced.task };
 
     // This transaction already checked the tracker key, excluding the caller's