@desplega.ai/agent-swarm 1.115.0 → 1.117.0

package/dist/{rbac-roles-kfesjy9y.js → rbac-roles-chkhakmf.js}

@@ -7,13 +7,13 @@ import {
   getUserGrant,
   listUserRoles,
   runRbacCliCommand
-} from "./cli-52fg7s7x.js";
+} from "./cli-kfjs4fjw.js";
 import"./cli-86fdnerz.js";
-import"./cli-15y7qhzp.js";
+import"./cli-s5q026mr.js";
 import"./cli-z2zcxes1.js";
 import"./cli-bw80ck94.js";
 import"./cli-xz9aq0rf.js";
-import"./cli-b23axgz4.js";
+import"./cli-xcp5dmts.js";
 import"./cli-4j2mrzag.js";
 import"./cli-p9swy5t3.js";
 export {

package/dist/{rbac-roles-mwcwhbxc.js → rbac-roles-j2k0h8sx.js}

@@ -4,11 +4,11 @@ import {
 import {
   getDb,
   init_db
-} from "./cli-15y7qhzp.js";
+} from "./cli-s5q026mr.js";
 import"./cli-z2zcxes1.js";
 import"./cli-bw80ck94.js";
 import"./cli-xz9aq0rf.js";
-import"./cli-b23axgz4.js";
+import"./cli-xcp5dmts.js";
 import"./cli-4j2mrzag.js";
 import"./cli-p9swy5t3.js";
 

package/dist/{seed-pricing-h2kdq4cq.js → seed-pricing-vta6a1q3.js}

@@ -1,12 +1,12 @@
 import {
   buildModelsDevSeedRows,
   seedPricingFromModelsDev
-} from "./cli-tece6zgm.js";
-import"./cli-15y7qhzp.js";
+} from "./cli-q0yn57de.js";
+import"./cli-s5q026mr.js";
 import"./cli-z2zcxes1.js";
 import"./cli-bw80ck94.js";
 import"./cli-xz9aq0rf.js";
-import"./cli-b23axgz4.js";
+import"./cli-xcp5dmts.js";
 import"./cli-4j2mrzag.js";
 import"./cli-p9swy5t3.js";
 export {

package/dist/{setup-8506q97w.js → setup-yv9ctywz.js}

@@ -4,14 +4,14 @@ import {
   createDefaultMcpJson,
   createDefaultSettingsLocal,
   createHooksConfig
-} from "./cli-cnwssmsr.js";
+} from "./cli-6058t3w0.js";
 import {
   require_jsx_dev_runtime
 } from "./cli-wx82tw1k.js";
 import {
   getApiKey
 } from "./cli-f14fvzag.js";
-import"./cli-b23axgz4.js";
+import"./cli-xcp5dmts.js";
 import {
   Box_default,
   Spinner,

package/dist/{worker-4r5c6zyb.js → worker-7w6571j0.js}

@@ -1,6 +1,6 @@
 import {
   runAgent
-} from "./cli-zsrdty74.js";
+} from "./cli-09j7m5v3.js";
 import"./cli-tyfxrrdd.js";
 import"./cli-bc89my0z.js";
 import"./cli-yazx6hap.js";
@@ -14,7 +14,7 @@ import"./cli-d6n0thxw.js";
 import"./cli-yv9dttkh.js";
 import {
   getEnabledCapabilities
-} from "./cli-hrhye2rm.js";
+} from "./cli-r06ed00c.js";
 import"./cli-1z7048dy.js";
 import"./cli-ftyf58xj.js";
 import"./cli-tk9vyqzh.js";
@@ -25,36 +25,36 @@ import"./cli-psrqtw2m.js";
 import"./cli-zm7njwzd.js";
 import"./cli-tghre7g6.js";
 import"./cli-e61fs2hp.js";
-import"./cli-3samkyap.js";
-import"./cli-tece6zgm.js";
-import"./cli-52fg7s7x.js";
+import"./cli-fep22bhf.js";
+import"./cli-q0yn57de.js";
+import"./cli-kfjs4fjw.js";
 import"./cli-86fdnerz.js";
-import"./cli-dcca6j8m.js";
+import"./cli-yarjrgd5.js";
 import"./cli-fad8m16k.js";
-import"./cli-shvaxw27.js";
-import"./cli-q1rx7g0d.js";
+import"./cli-t6n84nqv.js";
+import"./cli-e0xv4nd4.js";
 import"./cli-f14fvzag.js";
-import"./cli-r9f6ngrf.js";
+import"./cli-vwhg6sbn.js";
 import"./cli-jkhwmmgg.js";
-import"./cli-cmw9rzy5.js";
-import"./cli-7xje5amz.js";
+import"./cli-z824vphk.js";
+import"./cli-rymspw51.js";
 import"./cli-q25ejbyn.js";
-import"./cli-t0vqevnm.js";
+import"./cli-hmw1vk30.js";
 import"./cli-0pygq9r1.js";
-import"./cli-tffvrh6j.js";
-import"./cli-pet3aev6.js";
+import"./cli-9kk0xa5w.js";
+import"./cli-jkp1gndy.js";
 import"./cli-rkndnn90.js";
 import"./cli-b0p7rfnd.js";
-import"./cli-6aq8xhvm.js";
+import"./cli-w5axeg22.js";
 import"./cli-ma04faw5.js";
 import"./cli-wspgs9bt.js";
-import"./cli-k3y4z3h5.js";
+import"./cli-5ekf4gcj.js";
 import"./cli-dh55d5fg.js";
-import"./cli-15y7qhzp.js";
+import"./cli-s5q026mr.js";
 import"./cli-z2zcxes1.js";
 import"./cli-bw80ck94.js";
 import"./cli-xz9aq0rf.js";
-import"./cli-b23axgz4.js";
+import"./cli-xcp5dmts.js";
 import"./cli-4j2mrzag.js";
 import"./cli-e15jhafb.js";
 import"./cli-9aryf9tv.js";

package/openapi.json

@@ -2,7 +2,7 @@
   "openapi": "3.1.0",
   "info": {
     "title": "Agent Swarm API",
-    "version": "1.115.0",
+    "version": "1.117.0",
     "description": "Multi-agent orchestration API for Claude Code, Codex, and Gemini CLI. Enables task distribution, agent communication, and service discovery.\n\nMCP tools are documented separately in [MCP.md](./MCP.md)."
   },
   "servers": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@desplega.ai/agent-swarm",
-  "version": "1.115.0",
+  "version": "1.117.0",
   "description": "Multi-agent orchestration for Claude Code, Codex, Gemini CLI, and other AI coding assistants",
   "license": "MIT",
   "author": "desplega.sh <contact@desplega.sh>",
@@ -146,7 +146,7 @@
     "@inkjs/ui": "^2.0.0",
     "@linear/sdk": "^77.0.0",
     "@modelcontextprotocol/sdk": "^1.25.1",
-    "@openai/codex-sdk": "^0.143.0",
+    "@openai/codex-sdk": "^0.144.1",
     "@opencode-ai/sdk": "^1.17.15",
     "@openfort/openfort-node": "^0.9.1",
     "@opentelemetry/api": "^1.9.1",

package/src/be/db.ts

@@ -2,6 +2,7 @@ import { Database } from "bun:sqlite";
 import { parseProviderMeta } from "@/utils/provider-metadata.ts";
 import pkg from "../../package.json";
 import { configureDbResolver } from "../prompts/resolver";
+import { slackChannelFromContextKey } from "../tasks/slack-routing";
 import { telemetry } from "../telemetry";
 import type {
   ActiveSession,
@@ -3338,6 +3339,16 @@ export interface CreateTaskOptions {
   slackChannelId?: string;
   slackThreadTs?: string;
   slackUserId?: string;
+  /**
+   * Opt out of the residual Slack/contextKey normalization below (see the
+   * "Residual-mismatch guard" comment near the INSERT): a deliberate
+   * cross-channel/thread dispatch (e.g. `send-task`'s
+   * `overrideSlackContext: true`) sets this so its explicit slackChannelId/
+   * slackThreadTs survive even when they disagree with a slack-family
+   * `contextKey`/parent. Trusted callers that don't set this get normalized —
+   * this boundary must not let a caller silently persist a mismatch.
+   */
+  overrideSlackContext?: boolean;
   vcsProvider?: "github" | "gitlab";
   vcsRepo?: string;
   vcsEventType?: string;
@@ -3450,14 +3461,24 @@ export function createTaskExtended(task: string, options?: CreateTaskOptions): A
       // is the single source of truth — `createResumeFollowUp` and the other
       // follow-up creators rely on this block instead of re-listing fields.
 
-      // Slack context
+      // Slack context — inherited as an atomic unit. A foreign channelId's
+      // thread ts is meaningless to Slack's API, so an explicit slackChannelId
+      // that DIFFERS from the parent's must not pull in the parent's
+      // slackThreadTs/slackUserId (that combination misroutes/fails to thread —
+      // see swarm memory dispatch-slack-channel-must-match-parent-context-2026-07-10).
+      // When the explicit channel matches the parent's (or is unset), per-field
+      // fill-in proceeds as before.
+      const explicitForeignChannel =
+        !!options.slackChannelId &&
+        !!parent.slackChannelId &&
+        options.slackChannelId !== parent.slackChannelId;
       if (parent.slackChannelId && !options.slackChannelId) {
         options.slackChannelId = parent.slackChannelId;
       }
-      if (parent.slackThreadTs && !options.slackThreadTs) {
+      if (parent.slackThreadTs && !options.slackThreadTs && !explicitForeignChannel) {
         options.slackThreadTs = parent.slackThreadTs;
       }
-      if (parent.slackUserId && !options.slackUserId) {
+      if (parent.slackUserId && !options.slackUserId && !explicitForeignChannel) {
         options.slackUserId = parent.slackUserId;
       }
 
@@ -3585,6 +3606,71 @@ export function createTaskExtended(task: string, options?: CreateTaskOptions): A
     }
   }
 
+  // contextKey → Slack-fields backfill: a slack-family contextKey is the
+  // durable record of where this task belongs, but delivery code
+  // (src/slack/responses.ts, src/slack/watcher.ts, src/tools/slack-reply.ts)
+  // reads slackChannelId/slackThreadTs exclusively. Without this, a task that
+  // inherited only a slack contextKey (no Slack fields) would silently never
+  // deliver. Deliberately does NOT backfill slackUserId — the key doesn't
+  // encode it.
+  if (!options?.slackChannelId) {
+    const backfill = slackChannelFromContextKey(options?.contextKey);
+    if (backfill && options) {
+      options.slackChannelId = backfill.channelId;
+      options.slackThreadTs = backfill.threadTs;
+    }
+  } else if (!options.slackThreadTs) {
+    // Channel present but no thread: a trusted caller supplied slackChannelId
+    // without slackThreadTs. If it matches the slack-family contextKey's
+    // channel, fill the thread from there too — otherwise delivery (which
+    // reads slackThreadTs directly) silently fails to thread.
+    const backfill = slackChannelFromContextKey(options.contextKey);
+    if (backfill && backfill.channelId === options.slackChannelId) {
+      options.slackThreadTs = backfill.threadTs;
+    }
+  }
+
+  // Residual-mismatch guard: after all inheritance/backfill above, a final
+  // slackChannelId/slackThreadTs that still disagrees with a slack-family
+  // contextKey would misroute delivery — src/slack/responses.ts,
+  // src/slack/watcher.ts, and src/tools/slack-reply.ts all read these fields
+  // directly, so logging a warning and inserting the mismatch unchanged does
+  // NOT prevent misdelivery. This boundary is reachable by untrusted-ish
+  // callers too (e.g. POST /api/tasks accepts client-supplied parentTaskId +
+  // contextKey), so a non-override caller must not be able to persist a
+  // mismatch: the durable contextKey wins and the Slack fields are
+  // normalized to match it. `overrideSlackContext` (set by `send-task` when
+  // the caller passed `overrideSlackContext: true`) opts out, preserving the
+  // deliberately divergent lineage. Never throw here — this also runs on
+  // trusted ingress hot paths that must not fail task creation.
+  const finalSlackContext = slackChannelFromContextKey(options?.contextKey);
+  if (finalSlackContext && options?.slackChannelId) {
+    if (options.slackChannelId !== finalSlackContext.channelId) {
+      if (options.overrideSlackContext) {
+        console.log(
+          `[slack-routing] override: keeping slackChannelId="${options.slackChannelId}" despite disagreeing with contextKey channel "${finalSlackContext.channelId}" (contextKey=${options.contextKey}, sourceTaskId=${options.sourceTaskId ?? "n/a"}, parentTaskId=${options.parentTaskId ?? "n/a"})`,
+        );
+      } else {
+        console.warn(
+          `[slack-routing] MISMATCH task creation: normalizing slackChannelId="${options.slackChannelId}" to contextKey channel "${finalSlackContext.channelId}" (contextKey=${options.contextKey}, sourceTaskId=${options.sourceTaskId ?? "n/a"}, parentTaskId=${options.parentTaskId ?? "n/a"})`,
+        );
+        options.slackChannelId = finalSlackContext.channelId;
+        options.slackThreadTs = finalSlackContext.threadTs;
+      }
+    } else if (options.slackThreadTs && options.slackThreadTs !== finalSlackContext.threadTs) {
+      if (options.overrideSlackContext) {
+        console.log(
+          `[slack-routing] override: keeping slackThreadTs="${options.slackThreadTs}" despite disagreeing with contextKey thread "${finalSlackContext.threadTs}" (contextKey=${options.contextKey}, sourceTaskId=${options.sourceTaskId ?? "n/a"}, parentTaskId=${options.parentTaskId ?? "n/a"})`,
+        );
+      } else {
+        console.warn(
+          `[slack-routing] MISMATCH task creation: normalizing slackThreadTs="${options.slackThreadTs}" to contextKey thread "${finalSlackContext.threadTs}" (contextKey=${options.contextKey}, sourceTaskId=${options.sourceTaskId ?? "n/a"}, parentTaskId=${options.parentTaskId ?? "n/a"})`,
+        );
+        options.slackThreadTs = finalSlackContext.threadTs;
+      }
+    }
+  }
+
   const auditUserId = getCurrentRequestUserId() ?? null;
   const row = getDb()
     .prepare<AgentTaskRow, (string | number | null)[]>(

package/src/server-user.ts

@@ -116,6 +116,7 @@ export function createUserServer(user: User): McpServer {
     return sendTaskHandler(userCtx(user, info.sessionId), {
       offerMode: false,
       allowDuplicate: false,
+      overrideSlackContext: false,
       ...args,
     });
   });

package/src/tasks/slack-routing.ts

@@ -0,0 +1,147 @@
+/**
+ * Slack-routing coherence guard.
+ *
+ * A task's Slack destination is carried by three fields — `slackChannelId`,
+ * `slackThreadTs`, `slackUserId` — which delivery code (`src/slack/responses.ts`,
+ * `src/slack/watcher.ts`, `src/tools/slack-reply.ts`) reads directly, alongside
+ * the durable, immutable `contextKey` that records where a task's ingress
+ * entity actually lives. Nothing upstream compared the two before creating a
+ * task, so a caller could hand-type a `slackChannelId` that disagreed with
+ * both the parent task and the inherited `contextKey`, silently misrouting a
+ * worker's completion summary into the wrong human's DM (see swarm memory
+ * `dispatch-slack-channel-must-match-parent-context-2026-07-10`).
+ *
+ * This module is pure and dependency-light (only the `AgentTask` type +
+ * `parseContextKey`) so it can be imported from both the agent-facing tool
+ * boundary (`src/tools/send-task.ts`, strict-reject) and the DB boundary
+ * (`src/be/db.ts` `createTaskExtended`, normalize-and-warn).
+ */
+
+import type { AgentTask } from "../types";
+import { parseContextKey } from "./context-key";
+
+export type SlackUnit = {
+  channelId?: string | null;
+  threadTs?: string | null;
+  userId?: string | null;
+};
+
+export type SlackRoutingVerdict =
+  | { verdict: "ok" }
+  | { verdict: "partial-unit"; detail: string }
+  | {
+      verdict: "mismatch";
+      field: "slackChannelId" | "slackThreadTs";
+      expected: string;
+      expectedSource: "parent" | "contextKey";
+      got: string;
+      detail: string;
+    };
+
+/**
+ * Parse the Slack channel/thread encoded in a `contextKey`, iff it is
+ * slack-family. Returns `null` for non-slack families and for malformed keys
+ * — a parse failure here must never throw, since this runs on hot creation
+ * paths that also handle non-Slack ingress.
+ */
+export function slackChannelFromContextKey(
+  key: string | null | undefined,
+): { channelId: string; threadTs: string } | null {
+  if (!key) return null;
+  try {
+    const parsed = parseContextKey(key);
+    if (parsed.family !== "slack") return null;
+    return { channelId: parsed.parts.channelId, threadTs: parsed.parts.threadTs };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check whether an explicit Slack unit is coherent with the parent task and
+ * the contextKey the new task will carry. `channelId`/`threadTs` must be
+ * both-or-neither (delivery requires both); when a channel is present it
+ * must agree with the parent's `slackChannelId` AND `slackThreadTs` (if set)
+ * and with the channel/thread encoded in a slack-family `inheritedContextKey`
+ * (if any). `userId` is attribution only and is never checked — it is
+ * harmless on its own. Callers that want a deliberate cross-channel/thread
+ * dispatch skip this check entirely (see `overrideSlackContext` at the
+ * `send-task` boundary) rather than passing a bypass flag into this helper.
+ */
+export function checkSlackRoutingCoherence(input: {
+  explicit: SlackUnit;
+  parent?: Pick<AgentTask, "slackChannelId" | "slackThreadTs" | "contextKey"> | null;
+  inheritedContextKey?: string | null;
+}): SlackRoutingVerdict {
+  const { explicit, parent, inheritedContextKey } = input;
+  const hasChannel = !!explicit.channelId;
+  const hasThread = !!explicit.threadTs;
+
+  if (hasChannel !== hasThread) {
+    return {
+      verdict: "partial-unit",
+      detail: hasChannel
+        ? `slackChannelId "${explicit.channelId}" was passed without slackThreadTs — both are required together for Slack delivery to work.`
+        : `slackThreadTs "${explicit.threadTs}" was passed without slackChannelId — both are required together for Slack delivery to work.`,
+    };
+  }
+
+  if (!hasChannel) {
+    return { verdict: "ok" };
+  }
+
+  const channelId = explicit.channelId as string;
+  const threadTs = explicit.threadTs as string;
+
+  if (parent?.slackChannelId && channelId !== parent.slackChannelId) {
+    return {
+      verdict: "mismatch",
+      field: "slackChannelId",
+      expected: parent.slackChannelId,
+      expectedSource: "parent",
+      got: channelId,
+      detail: `explicit slackChannelId "${channelId}" does not match the parent task's slackChannelId "${parent.slackChannelId}".`,
+    };
+  }
+
+  // Same channel as the parent, but a different thread: the DB still
+  // preserves an explicit slackThreadTs verbatim and delivery reads it
+  // directly, so this would post to the wrong thread in the parent's own
+  // channel. Only meaningful once we know the channel agrees (above).
+  if (parent?.slackThreadTs && threadTs !== parent.slackThreadTs) {
+    return {
+      verdict: "mismatch",
+      field: "slackThreadTs",
+      expected: parent.slackThreadTs,
+      expectedSource: "parent",
+      got: threadTs,
+      detail: `explicit slackThreadTs "${threadTs}" does not match the parent task's slackThreadTs "${parent.slackThreadTs}" (same channel "${parent.slackChannelId}").`,
+    };
+  }
+
+  const contextKeySlack = slackChannelFromContextKey(inheritedContextKey);
+  if (contextKeySlack) {
+    if (channelId !== contextKeySlack.channelId) {
+      return {
+        verdict: "mismatch",
+        field: "slackChannelId",
+        expected: contextKeySlack.channelId,
+        expectedSource: "contextKey",
+        got: channelId,
+        detail: `explicit slackChannelId "${channelId}" does not match the channel encoded in contextKey "${inheritedContextKey}" ("${contextKeySlack.channelId}").`,
+      };
+    }
+    if (threadTs !== contextKeySlack.threadTs) {
+      return {
+        verdict: "mismatch",
+        field: "slackThreadTs",
+        expected: contextKeySlack.threadTs,
+        expectedSource: "contextKey",
+        got: threadTs,
+        detail: `explicit slackThreadTs "${threadTs}" does not match the thread encoded in contextKey "${inheritedContextKey}" ("${contextKeySlack.threadTs}").`,
+      };
+    }
+  }
+
+  return { verdict: "ok" };
+}

package/src/tests/approval-requests.test.ts

@@ -10,6 +10,7 @@ import {
   getAgentCurrentTask,
   getApprovalRequestById,
   getApprovalRequestByStepId,
+  getDb,
   getExpiredPendingApprovals,
   initDb,
   listApprovalRequests,
@@ -441,6 +442,41 @@ describe("Approval Requests", () => {
       }
     });
 
+    test("applies status before limiting newer rows", async () => {
+      const pending = createApprovalRequest(makeApprovalData({ title: "Older pending request" }));
+      getDb()
+        .prepare("UPDATE approval_requests SET createdAt = ? WHERE id = ?")
+        .run("2099-01-01T00:00:00.000Z", pending.id);
+
+      for (const index of [1, 2]) {
+        const resolved = createApprovalRequest(
+          makeApprovalData({ title: `Newer resolved request ${index}` }),
+        );
+        resolveApprovalRequest(resolved.id, {
+          status: "approved",
+          responses: { q1: { approved: true } },
+        });
+        getDb()
+          .prepare("UPDATE approval_requests SET createdAt = ? WHERE id = ?")
+          .run(`2100-01-0${index}T00:00:00.000Z`, resolved.id);
+      }
+
+      const unfiltered = await fetch(`${baseUrl}/api/approval-requests?limit=1`);
+      const unfilteredData = (await unfiltered.json()) as {
+        approvalRequests: Array<{ id: string }>;
+      };
+      expect(unfilteredData.approvalRequests[0]?.id).not.toBe(pending.id);
+
+      const filtered = await fetch(`${baseUrl}/api/approval-requests?status=pending&limit=1`);
+      expect(filtered.status).toBe(200);
+      const filteredData = (await filtered.json()) as {
+        approvalRequests: Array<{ id: string; status: string }>;
+      };
+      expect(filteredData.approvalRequests).toEqual([
+        expect.objectContaining({ id: pending.id, status: "pending" }),
+      ]);
+    });
+
     test("filters by workflowRunId", async () => {
       const runId = crypto.randomUUID();
       // Create one with this runId

package/src/tests/http-api-integration.test.ts

@@ -9,6 +9,7 @@ import { randomUUID } from "node:crypto";
 import { rm, unlink } from "node:fs/promises";
 import type { Subprocess } from "bun";
 import { Webhook } from "svix";
+import { slackContextKey } from "../tasks/context-key";
 
 const TEST_PORT = 19876;
 const TEST_DB_PATH = `/tmp/test-http-integration-${Date.now()}.sqlite`;
@@ -432,6 +433,43 @@ describe("Tasks", () => {
     expect(status).toBe(404);
   });
 
+  test("POST /api/tasks — client-supplied parentTaskId + contextKey cannot persist a Slack route/contextKey mismatch", async () => {
+    // POST /api/tasks doesn't accept slackChannelId/slackThreadTs directly,
+    // but a slack-family contextKey backfills them (src/be/db.ts). Build a
+    // parent whose Slack unit lives in channel A this way.
+    const contextKeyA = slackContextKey({ channelId: "HTTP_CHAN_A", threadTs: "1111.1111" });
+    const parent = await post("/api/tasks", {
+      agentId: ids.leadAgent,
+      body: {
+        task: "HTTP parent task in channel A",
+        contextKey: contextKeyA,
+      },
+    });
+    expect(parent.status).toBe(201);
+    expect(parent.body.slackChannelId).toBe("HTTP_CHAN_A");
+
+    // A child that inherits the parent's Slack unit (via parentTaskId) but
+    // carries an explicit contextKey for a DIFFERENT channel B — exactly the
+    // client-supplied parentTaskId + contextKey shape the reviewer flagged.
+    const contextKeyB = slackContextKey({ channelId: "HTTP_CHAN_B", threadTs: "2222.2222" });
+    const child = await post("/api/tasks", {
+      agentId: ids.leadAgent,
+      body: {
+        task: "HTTP child task claiming a different channel via contextKey",
+        parentTaskId: parent.body.id,
+        contextKey: contextKeyB,
+      },
+    });
+    expect(child.status).toBe(201);
+
+    // The durable contextKey (channel B) must win over the parent-inherited
+    // Slack unit (channel A) — a non-override HTTP caller cannot persist the
+    // mismatch that misroutes delivery.
+    expect(child.body.slackChannelId).toBe("HTTP_CHAN_B");
+    expect(child.body.slackThreadTs).toBe("2222.2222");
+    expect(child.body.contextKey).toBe(contextKeyB);
+  });
+
   test("PUT /api/tasks/:id/session — update session ID", async () => {
     const sessionId = randomUUID();
     const { status, body } = await put(`/api/tasks/${ids.task2}/session`, {

package/src/tests/pages-complete-fetch.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, test } from "bun:test";
+import {
+  fetchAllPages,
+  PAGES_BATCH_SIZE,
+  type PagesBatchFilters,
+} from "../../apps/ui/src/api/fetch-all-pages";
+import type { PageListItem } from "../../apps/ui/src/api/types";
+
+function page(index: number): PageListItem {
+  const timestamp = new Date(Date.UTC(2026, 0, 1, 0, 0, index)).toISOString();
+  return {
+    id: `page-${index}`,
+    agentId: index === 620 ? "matching-agent" : "other-agent",
+    slug: `page-${index}`,
+    title: `Page ${index}`,
+    contentType: "text/html",
+    authMode: "public",
+    body: "",
+    viewCount: 0,
+    createdAt: timestamp,
+    updatedAt: timestamp,
+    app_url: `/pages/page-${index}`,
+    api_url: `/p/page-${index}`,
+  };
+}
+
+describe("fetchAllPages", () => {
+  test("loads candidates beyond the default page and endpoint batch cap", async () => {
+    const source = Array.from({ length: 625 }, (_, index) => page(index));
+    const calls: PagesBatchFilters[] = [];
+
+    const result = await fetchAllPages(async (filters) => {
+      calls.push(filters);
+      const offset = filters.offset ?? 0;
+      const limit = filters.limit ?? 50;
+      return {
+        pages: source.slice(offset, offset + limit),
+        total: source.length,
+      };
+    });
+
+    expect(calls).toEqual([
+      { limit: PAGES_BATCH_SIZE, offset: 0 },
+      { limit: PAGES_BATCH_SIZE, offset: PAGES_BATCH_SIZE },
+    ]);
+    expect(result.pages).toHaveLength(source.length);
+    expect(result.pages.find((candidate) => candidate.agentId === "matching-agent")?.id).toBe(
+      "page-620",
+    );
+    expect(result.pages.map((candidate) => candidate.id)).toEqual(
+      source.map((candidate) => candidate.id),
+    );
+  });
+});