@desplega.ai/agent-swarm 2.7.2 → 2.7.3

package/src/be/db/tasks/read.ts

@@ -24,6 +24,7 @@ import { parseProviderMeta } from "../../../utils/provider-metadata";
 import { scrubSecrets } from "../../../utils/secret-scrubber";
 import { getAgentById } from "../agents";
 import { getDbClient } from "../runtime";
+import { taskSearchCondition } from "./search-index";
 
 type TaskReadDependencies = {
   checkDependencies: (taskId: string) => Promise<{ ready: boolean; blockedBy: string[] }>;
@@ -906,8 +907,9 @@ export async function getAllTasks(
   }
 
   if (filters?.search) {
-    conditions.push("(task LIKE ? OR title LIKE ? OR id LIKE ?)");
-    params.push(`%${filters.search}%`, `%${filters.search}%`, `%${filters.search}%`);
+    const search = await taskSearchCondition(filters.search, "page");
+    conditions.push(search.sql);
+    params.push(...search.params);
   }
 
   // New filters
@@ -1079,8 +1081,9 @@ export async function getTasksCount(
   }
 
   if (filters?.search) {
-    conditions.push("(task LIKE ? OR title LIKE ? OR id LIKE ?)");
-    params.push(`%${filters.search}%`, `%${filters.search}%`, `%${filters.search}%`);
+    const search = await taskSearchCondition(filters.search, "count");
+    conditions.push(search.sql);
+    params.push(...search.params);
   }
 
   if (filters?.unassigned) {

package/src/be/db/tasks/search-index.ts

@@ -0,0 +1,159 @@
+import { getDbClient } from "../runtime";
+
+/** `agent_tasks_fts_state.indexedThrough` once every row is indexed (migration 256). */
+export const TASK_FTS_COMPLETE = Number.MAX_SAFE_INTEGER;
+
+// At or below this many candidate rows, a page reads them by rowid and sorts
+// them. Above it, the page walks the lastUpdatedAt index and tests each row
+// against the index instead: sorting thousands of hits means reading each
+// row's record, and a long task body spills over many overflow pages.
+const ROWID_SET_MAX = 500;
+
+// Rows per backfill transaction. A task averages about 16 KB of text, so a
+// batch holds the write lock and the event loop for tens of milliseconds.
+const BACKFILL_BATCH_SIZE = 100;
+
+/**
+ * The agent_tasks_fts MATCH expression for free text: the whole input as one
+ * FTS5 phrase, so user text cannot inject operators (NEAR, AND, -, ^, column
+ * filters), with a prefix match on its last token. Returns null when the input
+ * has no indexable token (the phrase would match nothing).
+ */
+export function buildTaskFtsMatch(search: string): string | null {
+  if (!/[\p{L}\p{N}]/u.test(search)) return null;
+  return `"${search.replaceAll('"', '""')}"*`;
+}
+
+/**
+ * The WHERE term for a task `search`: a token and phrase match on the task
+ * text and title through agent_tasks_fts, or a prefix of the task id. Until
+ * the post-boot backfill has indexed every row it is the old substring LIKE,
+ * so results never miss rows the index has not reached yet.
+ *
+ * `purpose` picks the plan. A page with few candidates reads them by rowid; a
+ * page with many walks its ORDER BY index and tests membership (`+rowid`
+ * keeps the planner off the rowid set), stopping at the page size. A count
+ * has no LIMIT to stop at, so it always drives from the candidate set.
+ */
+export async function taskSearchCondition(
+  search: string,
+  purpose: "page" | "count",
+): Promise<{ sql: string; params: string[] }> {
+  const client = getDbClient();
+  const state = await client.get<{ indexedThrough: number }>(
+    "SELECT indexedThrough FROM agent_tasks_fts_state WHERE id = 1",
+  );
+  if (!state || state.indexedThrough < TASK_FTS_COMPLETE) {
+    const pattern = `%${search}%`;
+    return {
+      sql: "(task LIKE ? OR title LIKE ? OR id LIKE ?)",
+      params: [pattern, pattern, pattern],
+    };
+  }
+
+  const match = buildTaskFtsMatch(search);
+  // Task ids are lowercase UUIDs; a prefix is a range on the primary key.
+  const idLow = search.trim().toLowerCase();
+  const idRange = idLow ? [idLow, `${idLow}\uffff`] : null;
+  if (!match && !idRange) return { sql: "0", params: [] };
+
+  const arms: string[] = [];
+  const armParams: string[] = [];
+  if (match) {
+    arms.push("SELECT rowid AS rid FROM agent_tasks_fts WHERE agent_tasks_fts MATCH ?");
+    armParams.push(match);
+  }
+  if (idRange) {
+    arms.push("SELECT rowid AS rid FROM agent_tasks WHERE id >= ? AND id < ?");
+    armParams.push(...idRange);
+  }
+  const candidates = await client.query<{ rid: number }>(
+    `${arms.join(" UNION ")} LIMIT ${ROWID_SET_MAX + 1}`,
+    armParams,
+  );
+  if (candidates.length === 0) return { sql: "0", params: [] };
+  if (candidates.length <= ROWID_SET_MAX) {
+    return {
+      sql: `agent_tasks.rowid IN (${candidates.map((row) => row.rid).join(", ")})`,
+      params: [],
+    };
+  }
+
+  const rowid = purpose === "page" ? "+agent_tasks.rowid" : "agent_tasks.rowid";
+  const terms: string[] = [];
+  const params: string[] = [];
+  if (match) {
+    terms.push(`${rowid} IN (SELECT rowid FROM agent_tasks_fts WHERE agent_tasks_fts MATCH ?)`);
+    params.push(match);
+  }
+  if (idRange) {
+    terms.push("(agent_tasks.id >= ? AND agent_tasks.id < ?)");
+    params.push(...idRange);
+  }
+  return { sql: `(${terms.join(" OR ")})`, params };
+}
+
+/**
+ * Index the rows migration 256 left out, in rowid batches. Each batch and the
+ * `indexedThrough` mark that admits it to the triggers commit together, so a
+ * concurrent write is indexed exactly once: by its trigger when its row is
+ * already covered, else by a later batch. The last batch sets the mark to
+ * TASK_FTS_COMPLETE, which switches search to the index. Resumable after a
+ * restart; a no-op once complete.
+ */
+export async function backfillTaskSearchIndex(
+  batchSize = BACKFILL_BATCH_SIZE,
+): Promise<{ indexed: number; ms: number }> {
+  const client = getDbClient();
+  const startedAt = performance.now();
+  let indexed = 0;
+  while (!stopRequested) {
+    const done = await client.transaction(async (tx) => {
+      const state = await tx.get<{ indexedThrough: number }>(
+        "SELECT indexedThrough FROM agent_tasks_fts_state WHERE id = 1",
+      );
+      if (!state || state.indexedThrough >= TASK_FTS_COMPLETE) return true;
+      const last = await tx.get<{ rid: number }>(
+        "SELECT rowid AS rid FROM agent_tasks WHERE rowid > ? ORDER BY rowid LIMIT 1 OFFSET ?",
+        [state.indexedThrough, batchSize - 1],
+      );
+      const through = last?.rid ?? TASK_FTS_COMPLETE;
+      const result = await tx.run(
+        `INSERT INTO agent_tasks_fts(rowid, task, title)
+         SELECT rowid, task, title FROM agent_tasks WHERE rowid > ? AND rowid <= ?`,
+        [state.indexedThrough, through],
+      );
+      indexed += result.changes;
+      await tx.run("UPDATE agent_tasks_fts_state SET indexedThrough = ? WHERE id = 1", [through]);
+      return through >= TASK_FTS_COMPLETE;
+    });
+    if (done) break;
+    await new Promise<void>((resolve) => setImmediate(resolve));
+  }
+  return { indexed, ms: Math.round(performance.now() - startedAt) };
+}
+
+let backfill: Promise<void> | null = null;
+let stopRequested = false;
+
+/** Start the backfill once per process, off the boot path. */
+export function startTaskSearchBackfill(): Promise<void> {
+  stopRequested = false;
+  backfill ??= backfillTaskSearchIndex()
+    .then(({ indexed, ms }) => {
+      if (indexed > 0) console.log(`[task-fts] backfill indexed=${indexed} ms=${ms}`);
+    })
+    .catch((err) => {
+      console.error("[task-fts] backfill failed:", (err as Error).message);
+    })
+    .finally(() => {
+      backfill = null;
+    });
+  return backfill;
+}
+
+/** Stop after the current batch, before SQLite closes. The next start resumes. */
+export async function stopTaskSearchBackfill(): Promise<void> {
+  stopRequested = true;
+  await backfill;
+}

package/src/be/db/tasks/write.ts

@@ -19,6 +19,7 @@ import { emitTaskStarted } from "../../task-lifecycle-events";
 import { publishWorkerNudge } from "../../worker-nudges";
 import { getAgentById, isAgentEligibleForTask } from "../agents";
 import { getDbClient } from "../runtime";
+import { dropSessionDescendants } from "../session-summaries";
 import {
   classifyTaskHumanFree,
   reclassifyTaskHumanFree,
@@ -1138,6 +1139,8 @@ export async function deleteTask(id: string): Promise<boolean> {
     const childIds = (
       await tx.query<{ id: string }>("SELECT id FROM agent_tasks WHERE parentTaskId = ?", [id])
     ).map((row) => row.id);
+    // Its descendants leave the session too; the delete trigger handles the rest.
+    await dropSessionDescendants(id);
     const result = await tx.run("DELETE FROM agent_tasks WHERE id = ?", [id]);
     await reclassifyTaskHumanFree(childIds);
     return result.changes > 0;

package/src/be/db-queries/slack-inbound.ts

@@ -236,6 +236,83 @@ export async function admitSlackInboundReceipt(
   });
 }
 
+export interface RecordSlackInboundInlineInput {
+  dedupKey: string;
+  transport: SlackInboundTransport;
+  kind: SlackInboundKind;
+  payloadType: string;
+  apiAppId?: string | null;
+  eventId?: string | null;
+  retryNum?: number | null;
+  retryReason?: string | null;
+}
+
+/**
+ * Remember the dedup key of a delivery that is about to run outside the drain.
+ *
+ * The row is a tombstone: terminal (`processed`), no payload, never claimable.
+ * Retention drops it with the other completed keys, after the window in which
+ * Slack still redelivers. It exists so a redelivery is dropped after a restart,
+ * when the in-memory `event_id` cache is gone. The key is written before the
+ * work runs, so a crash mid-run is never replayed, as for an `uncertain`
+ * receipt. Returns `duplicate` when the key was already stored, counting the
+ * sighting.
+ */
+export async function recordSlackInboundInline(
+  input: RecordSlackInboundInlineInput,
+  now: Date = new Date(),
+): Promise<"recorded" | "duplicate"> {
+  const nowIso = now.toISOString();
+  const inserted = await getDbClient().get<{ id: string }>(
+    `INSERT INTO slack_inbound_receipts (
+        id, dedup_key, transport, kind, payload_type, api_app_id, event_id,
+        payload_bytes, retry_num, retry_reason, state, attempts, outcome_code,
+        received_at, available_at, completed_at, payload_erased_at, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, 0, ?, ?, 'processed', 1, 'ran_inline', ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(dedup_key) DO NOTHING
+      RETURNING id`,
+    [
+      crypto.randomUUID(),
+      input.dedupKey,
+      input.transport,
+      input.kind,
+      input.payloadType,
+      input.apiAppId ?? null,
+      input.eventId ?? null,
+      input.retryNum ?? null,
+      input.retryReason ?? null,
+      nowIso,
+      nowIso,
+      nowIso,
+      nowIso,
+      nowIso,
+      nowIso,
+    ],
+  );
+  if (inserted) return "recorded";
+  await touchSlackInboundDuplicate(input.dedupKey, now);
+  return "duplicate";
+}
+
+/**
+ * Is this key stored? Counts the sighting as a duplicate delivery when it is.
+ * One atomic UPDATE, no read-then-write.
+ */
+export async function touchSlackInboundDuplicate(
+  dedupKey: string,
+  now: Date = new Date(),
+): Promise<boolean> {
+  const nowIso = now.toISOString();
+  const row = await getDbClient().get<{ id: string }>(
+    `UPDATE slack_inbound_receipts
+        SET duplicate_count = duplicate_count + 1, last_duplicate_at = ?, updated_at = ?
+      WHERE dedup_key = ?
+      RETURNING id`,
+    [nowIso, nowIso, dedupKey],
+  );
+  return row !== null && row !== undefined;
+}
+
 /**
  * Atomically move one claimable pending receipt to `processing`. Without an id
  * the oldest available receipt is claimed. Returns null when nothing is

package/src/be/db.ts

@@ -25,6 +25,7 @@ import type {
   AgentLogEventType,
   AgentMcpServer,
   AgentSkill,
+  AgentSlackIcon,
   AgentStatus,
   AgentTask,
   AgentTaskStatus,
@@ -127,6 +128,7 @@ import {
   CreateTaskOptionsSchema,
   isTerminalTaskStatus,
   type ModelTier,
+  OPEN_TASK_STATUSES,
   parseModelTier,
   SERVER_GENERATED_ATTACHMENT_CAPABILITY,
   SessionCostModelBreakdownSchema,
@@ -2435,17 +2437,23 @@ async function findLatestRoutingCandidate(
 async function captureRoutingDecisionSnapshot(
   options: CreateTaskOptions,
 ): Promise<RoutingDecisionSnapshot> {
+  // MATERIALIZED pins the plan: a status seek over the few open tasks. Without
+  // it (and with no sqlite_stat1) the planner flattens the CTE back into an OR
+  // over agentId/offeredTo that reads each agent's whole task history.
   const workerStatuses = await getDbClient().query<RoutingDecisionWorkerStatus>(
-    `SELECT agent.id AS agentId, agent.status,
+    `WITH open_task AS MATERIALIZED (
+         SELECT id, agentId, offeredTo, status FROM agent_tasks
+          WHERE status IN (${OPEN_TASK_STATUSES.map(() => "?").join(", ")})
+       )
+       SELECT agent.id AS agentId, agent.status,
          COUNT(task.id) AS openTaskCount,
          SUM(CASE WHEN task.status IN ('in_progress', 'reviewing') THEN 1 ELSE 0 END) AS activeTaskCount
        FROM agents agent
-       LEFT JOIN agent_tasks task ON
-         (task.agentId = agent.id OR task.offeredTo = agent.id)
-         AND task.status NOT IN ('completed', 'failed', 'cancelled', 'superseded')
+       LEFT JOIN open_task task ON task.agentId = agent.id OR task.offeredTo = agent.id
        WHERE agent.isLead = 0
        GROUP BY agent.id, agent.status
        ORDER BY agent.id`,
+    [...OPEN_TASK_STATUSES],
   );
 
   const samePr =
@@ -3744,6 +3752,7 @@ export async function updateAgentProfile(
     heartbeatMd?: string;
     /** `null` resets to the deterministic fallback; omit the key to leave untouched. */
     avatar?: AgentAvatar | null;
+    slackIcon?: AgentSlackIcon | null;
   },
   meta?: VersionMeta,
   guard?: {
@@ -3891,6 +3900,8 @@ export async function updateAgentProfile(
     // untouched) from "key present with value null" (reset).
     const avatarProvided = Object.hasOwn(updates, "avatar");
     const avatarJson = updates.avatar ? JSON.stringify(updates.avatar) : null;
+    const slackIconProvided = Object.hasOwn(updates, "slackIcon");
+    const slackIconJson = updates.slackIcon ? JSON.stringify(updates.slackIcon) : null;
 
     const now = new Date().toISOString();
     const row = await tx.get<AgentRow>(
@@ -3906,6 +3917,7 @@ export async function updateAgentProfile(
           toolsMd = COALESCE(?, toolsMd),
           heartbeatMd = COALESCE(?, heartbeatMd),
           avatar = CASE WHEN ? = 1 THEN ? ELSE avatar END,
+          slack_icon = CASE WHEN ? = 1 THEN ? ELSE slack_icon END,
           lastUpdatedAt = ?
          WHERE id = ? RETURNING *`,
       [
@@ -3921,6 +3933,8 @@ export async function updateAgentProfile(
         writable.heartbeatMd ?? null,
         avatarProvided ? 1 : 0,
         avatarJson,
+        slackIconProvided ? 1 : 0,
+        slackIconJson,
         now,
         id,
       ],
@@ -8276,6 +8290,10 @@ export interface StuckWorkflowRun {
 }
 
 export async function getStuckWorkflowRuns(): Promise<StuckWorkflowRun[]> {
+  // CROSS JOIN fixes the join order: the few waiting steps drive, and each
+  // one seeks its task through idx_agent_tasks_workflowRunStepId, so `output`
+  // is read only for matched tasks. Driving from agent_tasks by status reads
+  // nearly every finished task.
   return getDbClient().query<StuckWorkflowRun>(
     `SELECT
         wr.id as runId,
@@ -8285,10 +8303,11 @@ export async function getStuckWorkflowRuns(): Promise<StuckWorkflowRun[]> {
         at.status as taskStatus,
         at.output as taskOutput,
         wr.workflowId
-      FROM workflow_runs wr
-      JOIN workflow_run_steps wrs ON wrs.runId = wr.id AND wrs.status = 'waiting'
-      JOIN agent_tasks at ON at.workflowRunStepId = wrs.id
-      WHERE wr.status = 'waiting'
+      FROM workflow_run_steps wrs
+      CROSS JOIN workflow_runs wr ON wr.id = wrs.runId
+      CROSS JOIN agent_tasks at ON at.workflowRunStepId = wrs.id
+      WHERE wrs.status = 'waiting'
+        AND wr.status = 'waiting'
         AND at.status IN ('completed', 'failed', 'cancelled')
       ORDER BY at.createdAt ASC, at.rowid ASC`,
   );

package/src/be/mcp-overflow-sweep.ts

@@ -0,0 +1,39 @@
+import { MCP_OVERFLOW_NAMESPACE } from "../kv-overflow";
+import { sweepExpiredKvPrefix } from "./db";
+
+export const MCP_OVERFLOW_SWEEP_INTERVAL_MS = 10 * 60 * 1000;
+
+let sweepTimer: ReturnType<typeof setInterval> | null = null;
+
+/**
+ * Delete expired MCP overflow values across every agent's namespace. Runs on
+ * a timer, not on the spill path: the DELETE of multi-MB values and its write
+ * lock would otherwise land on a read tool's request.
+ */
+export async function runMcpOverflowSweep(now = Date.now()): Promise<number> {
+  try {
+    const removed = await sweepExpiredKvPrefix(MCP_OVERFLOW_NAMESPACE, now);
+    if (removed > 0) {
+      console.debug(`[mcp-overflow] Sweep removed ${removed} expired value(s)`);
+    }
+    return removed;
+  } catch (err) {
+    console.error("[mcp-overflow] Sweep failed:", err);
+    return 0;
+  }
+}
+
+export function startMcpOverflowSweep(intervalMs = MCP_OVERFLOW_SWEEP_INTERVAL_MS): void {
+  if (sweepTimer) return;
+  sweepTimer = setInterval(() => {
+    void runMcpOverflowSweep();
+  }, intervalMs);
+  if (typeof sweepTimer?.unref === "function") sweepTimer.unref();
+}
+
+export function stopMcpOverflowSweep(): void {
+  if (sweepTimer) {
+    clearInterval(sweepTimer);
+    sweepTimer = null;
+  }
+}