@desplega.ai/agent-swarm 2.5.1 → 2.5.3

package/src/be/db/session-tree.ts

@@ -6,12 +6,23 @@ import {
 } from "../../assets/key";
 import { isTerminalTaskStatus, TERMINAL_TASK_STATUSES } from "../../types";
 import { getDbClient, literalPrefixPattern } from "../db";
-import { type SessionViewer, sessionViewerCondition } from "./session-visibility";
+import {
+  type SessionViewer,
+  sessionMineCondition,
+  sessionViewerCondition,
+} from "./session-visibility";
 
 export type SessionReadState = "unread" | "read" | "later" | "done";
 export interface SessionFilters {
   /** Restrict roots to these task sources. */
   source?: string[];
+  /** Leave out roots of these task sources (the older sessions v2 source filter). */
+  hideSource?: string[];
+  /**
+   * Keep only roots of these task sources (the sessions v2 source filter).
+   * Unlike `source`, an empty list matches no root.
+   */
+  showSource?: string[];
   /** Match root task text or title with a case-insensitive substring. */
   q?: string;
   /** Match the root requester, excluding NULL requester rows. */
@@ -36,19 +47,25 @@ export interface SessionFilters {
   now?: string;
   /** Exclude ownerless roots for user viewers to match the tree's visibility. */
   tree?: boolean;
+  /** For user viewers: only human-started roots of the viewer and shares (the "Mine" view). */
+  mine?: boolean;
   /** Match exactly this root (one session's summary, e.g. its read state). */
   rootId?: string;
 }
 
 type SqlFragment = { sql: string; params: (string | number | null)[] };
 
-/** Shared read-state rule with bound ISO timestamps for the list and tree. */
+/**
+ * Shared read-state rule with bound ISO timestamps for the list and tree.
+ * Done holds through agent activity (progress, status changes, child tasks):
+ * only `a.reopensDone`, counted in `sessionSummaryQuery`, brings it back.
+ */
 function sessionReadStateSql(now = new Date().toISOString()): SqlFragment {
   return {
     sql: `CASE
       WHEN s.id IS NULL THEN CASE WHEN a.lastActivityAt > ? THEN 'unread' ELSE 'read' END
       WHEN s.status = 'dismissed' THEN 'done'
-      WHEN s.status = 'done' THEN CASE WHEN a.lastActivityAt > s.lastUpdatedAt THEN 'unread' ELSE 'done' END
+      WHEN s.status = 'done' THEN CASE WHEN a.reopensDone > 0 THEN 'unread' ELSE 'done' END
       WHEN s.status = 'snoozed' THEN CASE WHEN s.snoozeUntil > ? THEN 'later' ELSE 'unread' END
       WHEN a.lastActivityAt > COALESCE(s.lastReadAt, s.lastUpdatedAt) THEN 'unread'
       ELSE 'read'
@@ -89,6 +106,17 @@ export function sessionRootFilter(opts: SessionFilters = {}): SqlFragment {
   const sources = opts.source?.filter(Boolean) ?? [];
   if (sources.length)
     add({ sql: `r.source IN (${sources.map(() => "?").join(",")})`, params: sources });
+  const hidden = opts.hideSource?.filter(Boolean) ?? [];
+  if (hidden.length)
+    add({ sql: `r.source NOT IN (${hidden.map(() => "?").join(",")})`, params: hidden });
+  if (opts.showSource) {
+    const shown = opts.showSource.filter(Boolean);
+    add(
+      shown.length
+        ? { sql: `r.source IN (${shown.map(() => "?").join(",")})`, params: shown }
+        : { sql: "0", params: [] },
+    );
+  }
   if (opts.q?.trim()) {
     const like = `%${opts.q.trim().toLowerCase()}%`;
     add({
@@ -106,6 +134,7 @@ export function sessionRootFilter(opts: SessionFilters = {}): SqlFragment {
   if (opts.viewer) {
     add(sessionViewerCondition(opts.viewer));
     if (opts.tree) conditions.push("r.requestedByUserId IS NOT NULL");
+    if (opts.mine) add(sessionMineCondition(opts.viewer.userId));
   }
   if (opts.keyPrefix) {
     const { lo, hi } = keyPrefixRange(opts.keyPrefix);
@@ -140,6 +169,35 @@ function hasSessionChainFilter(opts: SessionFilters): boolean {
 
 const runningSql = `latestStatus NOT IN (${TERMINAL_TASK_STATUSES.map((s) => `'${s}'`).join(",")})`;
 
+/**
+ * Sources of tasks that agents and the server create: delegation and scripts
+ * (`mcp`), follow-ups (`system`), deferred wake-ups (`schedule`) and workflow
+ * steps. Agents also set `requestedByUserId` explicitly on these, so a requester
+ * alone does not mark a human message.
+ */
+const AGENT_TASK_SOURCES = ["mcp", "system", "schedule", "workflow"] as const;
+
+/**
+ * Per chain row, over `chain` and the viewer's Done row `d`: whether the row
+ * needs the user since they marked the session Done. That is a human message
+ * (a task attributed to a person directly, not copied from its parent, from a
+ * human channel), a person's steering message on a chain task (steer or
+ * queue, not cancelled), or a pending approval, created after the Done mark.
+ * Steering `created_at` and the Done mark's `lastUpdatedAt` are both written
+ * as `%Y-%m-%dT%H:%M:%fZ`, so they compare as text.
+ */
+const reopensDoneSql = `(d.id IS NOT NULL AND (
+        (chain.createdAt > d.lastUpdatedAt
+          AND chain.requestedByUserId IS NOT NULL
+          AND chain.requestedByUserIdInherited = 0
+          AND COALESCE(chain.source, '') NOT IN (${AGENT_TASK_SOURCES.map((s) => `'${s}'`).join(",")}))
+        OR EXISTS (SELECT 1 FROM task_steering_messages sm
+          WHERE sm.task_id = chain.id AND sm.created_by_kind = 'user'
+            AND sm.status != 'cancelled' AND sm.created_at > d.lastUpdatedAt)
+        OR EXISTS (SELECT 1 FROM approval_requests ar
+          WHERE ar.sourceTaskId = chain.id AND ar.status = 'pending' AND ar.createdAt > d.lastUpdatedAt)
+      ))`;
+
 /**
  * A session starts at a parentTaskId IS NULL root. One recursive CTE computes
  * chain-wide latest activity for list ordering. Root filters precede recursion.
@@ -150,7 +208,7 @@ export function sessionSummaryQuery(opts: SessionFilters = {}): SqlFragment {
   const read = opts.viewer?.userId ? sessionReadStateSql(opts.now) : { sql: "NULL", params: [] };
   const params = [...root.params];
   if (opts.withUserId) params.push(opts.withUserId);
-  params.push(...read.params, opts.viewer?.userId ?? null);
+  params.push(opts.viewer?.userId ?? null, ...read.params, opts.viewer?.userId ?? null);
   const filters: string[] = [];
   if (opts.triage === "unread") filters.push("readState = 'unread'");
   else if (opts.triage === "later" || opts.triage === "done") {
@@ -170,19 +228,27 @@ export function sessionSummaryQuery(opts: SessionFilters = {}): SqlFragment {
   return {
     // SQLite takes the bare status from the row with MAX(lastUpdatedAt).
     // Keep this as the only MIN/MAX aggregate so status follows activity.
-    sql: `WITH RECURSIVE chain(root_id, id, lastUpdatedAt, status, requestedByUserId) AS (
-      SELECT r.id, r.id, r.lastUpdatedAt, r.status, r.requestedByUserId
+    // `d` is the viewer's Done row, so `reopensDone` can compare chain rows
+    // against the Done mark (SUM keeps MAX the only MIN/MAX aggregate).
+    sql: `WITH RECURSIVE chain(root_id, id, lastUpdatedAt, status, requestedByUserId,
+        createdAt, source, requestedByUserIdInherited) AS (
+      SELECT r.id, r.id, r.lastUpdatedAt, r.status, r.requestedByUserId,
+        r.createdAt, r.source, r.requestedByUserIdInherited
       FROM agent_tasks r WHERE ${root.sql}
       UNION ALL
-      SELECT c.root_id, t.id, t.lastUpdatedAt, t.status, t.requestedByUserId
+      SELECT c.root_id, t.id, t.lastUpdatedAt, t.status, t.requestedByUserId,
+        t.createdAt, t.source, t.requestedByUserIdInherited
       FROM chain c JOIN agent_tasks t ON t.parentTaskId = c.id
     ), agg AS (
-      SELECT root_id, COUNT(*) AS chainCount,
-        status AS latestStatus, MAX(lastUpdatedAt) AS lastActivityAt,
-        ${opts.withUserId ? "SUM(requestedByUserId = ?) AS withUser," : ""}
+      SELECT chain.root_id, COUNT(*) AS chainCount,
+        chain.status AS latestStatus, MAX(chain.lastUpdatedAt) AS lastActivityAt,
+        ${opts.withUserId ? "SUM(chain.requestedByUserId = ?) AS withUser," : ""}
         SUM(EXISTS (SELECT 1 FROM approval_requests ar
-          WHERE ar.sourceTaskId = chain.id AND ar.status = 'pending')) AS pendingApproval
-      FROM chain GROUP BY root_id
+          WHERE ar.sourceTaskId = chain.id AND ar.status = 'pending')) AS pendingApproval,
+        SUM(${reopensDoneSql}) AS reopensDone
+      FROM chain LEFT JOIN inbox_item_state d
+        ON d.userId = ? AND d.itemType = 'to_read' AND d.itemId = chain.root_id AND d.status = 'done'
+      GROUP BY chain.root_id
     ), state AS (
       SELECT a.*, ${read.sql} AS readState, s.snoozeUntil
       FROM agg a LEFT JOIN inbox_item_state s
@@ -322,25 +388,32 @@ export interface SessionTree {
   later: SessionSectionCounts;
   done: SessionSectionCounts;
   noGroup: SessionSectionCounts;
+  /** Each root source in this view with its session count, hidden sources included, most first. */
+  sources: { source: string; total: number }[];
 }
 
 export async function getSessionTree(
   actor: { kind: "bypass" } | { kind: "user"; userId: string | null },
   now?: string,
+  opts: { mine?: boolean; hideSource?: string[]; showSource?: string[] } = {},
 ): Promise<SessionTree> {
+  // No source filter in SQL: the source counts must include hidden sources,
+  // so the filter menu can offer them back. The loop skips them instead.
   const query = sessionSummaryQuery({
     ...(actor.kind === "user" ? { viewer: { userId: actor.userId, scope: "all" } as const } : {}),
     now,
     tree: true,
+    mine: opts.mine,
   });
   const rows = await getDbClient().query<{
     key: string;
+    source: string;
     lastActivityAt: string;
     latestStatus: string;
     readState: SessionReadState | null;
     needsYou: number;
   }>(
-    `SELECT r."key", a.lastActivityAt, a.latestStatus, a.readState, a.needsYou
+    `SELECT r."key", r.source, a.lastActivityAt, a.latestStatus, a.readState, a.needsYou
     FROM (${query.sql}) a CROSS JOIN agent_tasks r ON r.id = a.root_id`,
     query.params,
   );
@@ -351,7 +424,11 @@ export async function getSessionTree(
     later: counts(),
     done: counts(),
     noGroup: counts(),
+    sources: [],
   };
+  const hidden = new Set(opts.hideSource);
+  const shown = opts.showSource ? new Set(opts.showSource) : null;
+  const sources = new Map<string, number>();
   const groups = new Map<string, SessionTreeGroup>();
   const add = (section: SessionSectionCounts, row: (typeof rows)[number]) => {
     section.total++;
@@ -360,6 +437,8 @@ export async function getSessionTree(
     if (row.needsYou) section.needsYou++;
   };
   for (const row of rows) {
+    sources.set(row.source, (sources.get(row.source) ?? 0) + 1);
+    if (hidden.has(row.source) || (shown && !shown.has(row.source))) continue;
     const key = sessionGroupKey(row.key);
     const noGroup =
       key === "shared/" || (actor.kind === "user" && key === `personal/${actor.userId}/`);
@@ -380,5 +459,71 @@ export async function getSessionTree(
     }
   }
   result.groups = [...groups.values()].sort((a, b) => a.key.localeCompare(b.key));
+  result.sources = [...sources]
+    .map(([source, total]) => ({ source, total }))
+    .sort((a, b) => b.total - a.total || a.source.localeCompare(b.source));
   return result;
 }
+
+/** Triage actions on a whole list: the bulk bar's "Select all N". */
+export type SessionListTriage = "done" | "inbox" | "read" | "unread";
+
+/** The read cursor of "unread". The dashboard and the my-swarm app write the same value. */
+const UNREAD_CURSOR = "1970-01-01T00:00:00.000Z";
+
+/**
+ * Apply one triage action to every session a sidebar list shows `userId`
+ * (the same filters as `GET /api/sessions?scope=tree`), in one statement.
+ * The rows match what the dashboard writes for one session: Done, back to
+ * the Inbox, read up to the newest activity, or unread. Returns the number
+ * of sessions written.
+ */
+export async function triageSessionList(
+  userId: string,
+  filters: Pick<
+    SessionFilters,
+    "triage" | "noGroup" | "groupKey" | "mine" | "hideSource" | "showSource" | "now"
+  >,
+  action: SessionListTriage,
+): Promise<number> {
+  const now = filters.now ?? new Date().toISOString();
+  const query = sessionSummaryQuery({
+    ...filters,
+    now,
+    viewer: { userId, scope: "all" },
+    tree: true,
+  });
+  const status = action === "done" ? "done" : "open";
+  // `read` moves the cursor to each session's newest activity, `unread` to the epoch.
+  const lastReadAt =
+    action === "read" ? "a.lastActivityAt" : action === "unread" ? `'${UNREAD_CURSOR}'` : "NULL";
+  const setsLastRead = action === "read" || action === "unread";
+  // The conflict rules copy `upsertInboxState` in src/be/db.ts (sticky readAt,
+  // lastReadAt only when the action sets it, snooze and dismiss cleared). Keep
+  // the two in step. `WHERE true` is required: SQLite cannot parse
+  // INSERT ... SELECT ... ON CONFLICT when the SELECT has no WHERE clause.
+  const result = await getDbClient().run(
+    `INSERT INTO inbox_item_state
+      (userId, itemType, itemId, status, snoozeUntil, dismissedAt, doneAt, readAt, lastReadAt, createdAt, lastUpdatedAt)
+    SELECT ?, 'to_read', a.root_id, ?, NULL, NULL, ?, ?, ${lastReadAt}, ?, ?
+    FROM (${query.sql}) a WHERE true
+    ON CONFLICT(userId, itemType, itemId) DO UPDATE SET
+      status = excluded.status,
+      snoozeUntil = NULL,
+      dismissedAt = NULL,
+      doneAt = excluded.doneAt,
+      readAt = COALESCE(inbox_item_state.readAt, excluded.readAt),
+      lastReadAt = ${setsLastRead ? "excluded.lastReadAt" : "inbox_item_state.lastReadAt"},
+      lastUpdatedAt = excluded.lastUpdatedAt`,
+    [
+      userId,
+      status,
+      action === "done" ? now : null,
+      action === "read" ? now : null,
+      now,
+      now,
+      ...query.params,
+    ],
+  );
+  return result.changes;
+}

package/src/be/db/session-visibility.ts

@@ -27,3 +27,34 @@ export function sessionViewerCondition(viewer: SessionViewer): {
     params: [viewer.userId, viewer.userId],
   };
 }
+
+/**
+ * Root sources that a machine starts: a workflow run, a schedule, or the
+ * swarm itself (heartbeat, follow-ups, budget and approval notices). A
+ * workflow root carries the user whose trigger fired it, so the requester
+ * alone does not tell a person's session from fan-out. `kapso-inbound` is the
+ * exception: a WhatsApp message a person sent, written with `system`.
+ */
+export const MACHINE_SESSION_SOURCES = ["workflow", "schedule", "system"] as const;
+const HUMAN_SYSTEM_TASK_TYPES = ["kapso-inbound"] as const;
+
+/**
+ * The sessions v2 "Mine" view (alias `r`): roots this user started from a
+ * human channel (every source outside {@link MACHINE_SESSION_SOURCES}), plus
+ * sessions shared with this user or everyone. A list filter only: it narrows
+ * what a list shows and never changes who can open a session.
+ */
+export function sessionMineCondition(userId: string | null): {
+  sql: string;
+  params: (string | null)[];
+} {
+  const machine = MACHINE_SESSION_SOURCES.map(() => "?").join(",");
+  const humanSystem = HUMAN_SYSTEM_TASK_TYPES.map(() => "?").join(",");
+  return {
+    sql: `((r.requestedByUserId = ? AND (r.source NOT IN (${machine})
+        OR (r.source = 'system' AND r.taskType IN (${humanSystem}))))
+      OR EXISTS (SELECT 1 FROM session_shares s
+        WHERE s.rootTaskId = r.id AND s.revokedAt IS NULL AND (s.userId IS NULL OR s.userId = ?)))`,
+    params: [userId, ...MACHINE_SESSION_SOURCES, ...HUMAN_SYSTEM_TASK_TYPES, userId],
+  };
+}

package/src/be/db/skill-search.ts

@@ -0,0 +1,87 @@
+import { getDbClient } from "./runtime";
+
+// bm25() takes one weight per FTS column, in declaration order.
+// skills_fts (migration 239): skill_id (UNINDEXED), name, description, content.
+// skills_meta_fts (migration 241): skill_id (UNINDEXED), name, description.
+const SKILLS_FTS_BM25 = "bm25(skills_fts, 0.0, 3.0, 2.0, 1.0)";
+const SKILLS_META_FTS_BM25 = "bm25(skills_meta_fts, 0.0, 3.0, 2.0)";
+
+// FTS5 bm25 normalizes by the length of the whole row, so in skills_fts a
+// long SKILL.md body buries a name or description hit. skills_meta_fts holds
+// only those short fields; its score is added at this multiple. On the live
+// catalog, multiples from 2 to 10 rank the same; 3 is mid-range.
+const META_SCORE_MULTIPLE = 3;
+
+// English function words that agents put in natural-language queries. Each
+// one matches most of the catalog ("a" matched 189 of 189 skills) and only
+// adds noise to the ranking.
+const STOPWORDS = new Set(
+  (
+    "a an and are as at be but by can do does for from get got have how i if in into is it its " +
+    "me my need of on or our should so that the their them then there these this to use using " +
+    "want was we what when where which who why will with would you your"
+  ).split(" "),
+);
+
+/**
+ * Build a skills_fts MATCH expression from free text. Every term is quoted as
+ * an FTS5 string, so user text cannot inject operators (NEAR, AND, -, *, ^,
+ * column filters). Stopwords are dropped and the remaining terms are OR-ed:
+ * ranked recall, ordered by bm25. Returns null when no term is left, so the
+ * caller falls back to the substring match.
+ */
+export function buildSkillsFtsMatch(query: string): string | null {
+  const terms = query
+    .split(/[^\p{L}\p{N}_-]+/u)
+    .filter((term) => /[\p{L}\p{N}]/u.test(term) && !STOPWORDS.has(term.toLowerCase()))
+    .slice(0, 12);
+  if (terms.length === 0) return null;
+  return terms.map((term) => `"${term.replaceAll('"', '""')}"`).join(" OR ");
+}
+
+/**
+ * Enabled skills ranked by BM25: the skills_fts score (name 3, description 2,
+ * content 1) plus META_SCORE_MULTIPLE times the skills_meta_fts score (name 3,
+ * description 2). A skill whose name equals the whole query (case-insensitive)
+ * ranks first. Returns [] when the query has no indexable terms or the
+ * backend cannot run the FTS query, so the caller can fall back.
+ *
+ * `columns` is a select list over `skills`; it must not name a bare
+ * `skill_id` or `score`, which the joined `hits` and `meta` CTEs also expose.
+ */
+export async function searchSkillRowsRanked<T>(
+  query: string,
+  limit: number,
+  columns: string,
+): Promise<T[]> {
+  const match = buildSkillsFtsMatch(query);
+  if (!match) return [];
+  const exactName = query.trim();
+  try {
+    return await getDbClient().query<T>(
+      `WITH hits AS (
+         SELECT skill_id, ${SKILLS_FTS_BM25} AS score FROM skills_fts WHERE skills_fts MATCH ?
+       ),
+       meta AS (
+         SELECT skill_id, ${SKILLS_META_FTS_BM25} AS score
+         FROM skills_meta_fts WHERE skills_meta_fts MATCH ?
+       )
+       SELECT ${columns} FROM skills
+       LEFT JOIN hits ON hits.skill_id = skills.id
+       LEFT JOIN meta ON meta.skill_id = skills.id
+       WHERE skills.isEnabled = 1
+         AND (hits.skill_id IS NOT NULL OR lower(skills.name) = lower(?))
+       ORDER BY lower(skills.name) = lower(?) DESC,
+         COALESCE(hits.score, 0) + ${META_SCORE_MULTIPLE} * COALESCE(meta.score, 0) ASC,
+         skills.name ASC
+       LIMIT ?`,
+      [match, match, exactName, exactName, limit],
+    );
+  } catch (err) {
+    console.warn(
+      "[skills-fts] ranked query failed, using substring match:",
+      (err as Error).message,
+    );
+    return [];
+  }
+}

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

@@ -196,12 +196,39 @@ type AgentTaskTimelineRow = Pick<
  * past it).
  */
 const TASK_PREVIEW_BYTES = 4 * (TASK_PREVIEW_LENGTH + 1);
-const TASK_PREVIEW_SQL = `substr(CAST(agent_tasks.task AS BLOB), 1, ${TASK_PREVIEW_BYTES}) AS task`;
+/**
+ * A leading `<sibling_tasks_in_progress>` block (`src/tasks/sibling-block.ts`)
+ * is generated context that can fill the whole preview, so the list row never
+ * reaches the ask. The preview starts after the block and the `\n\n`
+ * `prependSiblingBlock` puts after it. A block with no closing tag stays.
+ */
+const SIBLING_OPEN = "<sibling_tasks_in_progress>";
+const SIBLING_CLOSE = "</sibling_tasks_in_progress>";
+const TASK_BLOB = "CAST(agent_tasks.task AS BLOB)";
+const SIBLING_CLOSE_AT = `instr(${TASK_BLOB}, CAST('${SIBLING_CLOSE}' AS BLOB))`;
+const SIBLING_END = `(${SIBLING_CLOSE_AT} + ${SIBLING_CLOSE.length})`;
+const TASK_PREVIEW_START = `CASE
+    WHEN substr(${TASK_BLOB}, 1, ${SIBLING_OPEN.length}) = CAST('${SIBLING_OPEN}' AS BLOB)
+      AND ${SIBLING_CLOSE_AT} > 0
+    THEN ${SIBLING_END} + (substr(${TASK_BLOB}, ${SIBLING_END}, 2) = x'0a0a') * 2
+    ELSE 1 END`;
+const TASK_PREVIEW_SQL = `substr(${TASK_BLOB}, ${TASK_PREVIEW_START}, ${TASK_PREVIEW_BYTES}) AS task`;
 // ignoreBOM keeps a leading U+FEFF, which the full-text preview keeps too.
 const taskPreviewDecoder = new TextDecoder("utf-8", { ignoreBOM: true });
 
+/** What `TASK_PREVIEW_START` does in SQL, for a full-text row. */
+function skipSiblingBlock(text: string): string {
+  if (!text.startsWith(SIBLING_OPEN)) return text;
+  const close = text.indexOf(SIBLING_CLOSE);
+  if (close === -1) return text;
+  const end = close + SIBLING_CLOSE.length;
+  return text.slice(text.startsWith("\n\n", end) ? end + 2 : end);
+}
+
 function taskPreview(task: TaskPreviewSource["task"]): string {
-  const text = task instanceof Uint8Array ? taskPreviewDecoder.decode(task) : task;
+  // Bytes come from `TASK_PREVIEW_SQL`, which already skipped the block.
+  const text =
+    task instanceof Uint8Array ? taskPreviewDecoder.decode(task) : skipSiblingBlock(task ?? "");
   return dependencies.previewText(text, TASK_PREVIEW_LENGTH);
 }
 
@@ -1715,6 +1742,18 @@ export async function getLatestLeadTaskInThread(
   return row ? rowToAgentTask(row) : null;
 }
 
+/**
+ * `source` filter of the contextKey lookups below. `'chat'` also matches a
+ * defer-task wake-up of a chat task: it keeps the chat contextKey with
+ * `source = 'schedule'` (src/scheduler/schedule-task.ts) and continues the
+ * same ask, so `/cancel`, steering and routing treat it as the chat task.
+ * Binds `source` three times.
+ */
+function contextKeySourceSql(alias = ""): string {
+  return `(? IS NULL OR ${alias}source = ?
+          OR (? = 'chat' AND ${alias}source = 'schedule' AND ${alias}taskType = 'deferred'))`;
+}
+
 /**
  * ContextKey twins of the Slack thread lookups above, for channels that key a
  * conversation by `contextKey` only (Chat SDK). `source` narrows to the
@@ -1731,7 +1770,7 @@ export async function getAgentWorkingOnContextKey(
   const taskRow = await getDbClient().get<AgentTaskRow>(
     `SELECT agentId FROM agent_tasks
        WHERE contextKey = ?
-       AND (? IS NULL OR source = ?)
+       AND ${contextKeySourceSql()}
        AND (? IS NULL
             OR status NOT IN (${TERMINAL_TASK_STATUSES.map(() => "?").join(", ")})
             OR finishedAt >= ?)
@@ -1741,6 +1780,7 @@ export async function getAgentWorkingOnContextKey(
       contextKey,
       source ?? null,
       source ?? null,
+      source ?? null,
       endedSince ?? null,
       ...TERMINAL_TASK_STATUSES,
       endedSince ?? null,
@@ -1760,11 +1800,11 @@ export async function getLatestActiveTaskByContextKey(
   const row = await getDbClient().get<AgentTaskRow>(
     `SELECT * FROM agent_tasks
        WHERE contextKey = ?
-       AND (? IS NULL OR source = ?)
+       AND ${contextKeySourceSql()}
        AND status IN ('in_progress', 'pending')
        ORDER BY createdAt DESC, rowid DESC
        LIMIT 1`,
-    [contextKey, source ?? null, source ?? null],
+    [contextKey, source ?? null, source ?? null, source ?? null],
   );
 
   return row ? rowToAgentTask(row) : null;
@@ -1780,11 +1820,11 @@ export async function getLatestLeadTaskByContextKey(
        FROM agent_tasks t
        JOIN agents a ON a.id = t.agentId
        WHERE t.contextKey = ?
-         AND (? IS NULL OR t.source = ?)
+         AND ${contextKeySourceSql("t.")}
          AND a.isLead = 1
        ORDER BY t.createdAt DESC, t.rowid DESC
        LIMIT 1`,
-    [contextKey, source ?? null, source ?? null],
+    [contextKey, source ?? null, source ?? null, source ?? null],
   );
 
   return row ? rowToAgentTask(row) : null;

package/src/be/db/workflow-runs.ts

@@ -4,7 +4,8 @@ import { scrubJsonValue } from "../scrub-json";
 import { getDbClient } from "./runtime";
 
 // Parent/child links between workflow runs (migration 203): a `sub-workflow`
-// step starts a child run that records the step in `parentStepId`.
+// step starts a child run that records the step in `parentStepId`, and the
+// step's `retryCount` at that time in `parentStepAttempt` (migration 240).
 
 const TERMINAL_STATUSES = new Set<WorkflowRunStatus>([
   "completed",
@@ -13,15 +14,60 @@ const TERMINAL_STATUSES = new Set<WorkflowRunStatus>([
   "skipped",
 ]);
 
-/** The id of the child run a `sub-workflow` step started, if any. */
-export async function getChildWorkflowRunId(parentStepId: string): Promise<string | null> {
+/** The id of the child run a `sub-workflow` step started on `attempt`, if any. */
+export async function getChildWorkflowRunId(
+  parentStepId: string,
+  attempt: number,
+): Promise<string | null> {
   const row = await getDbClient().get<{ id: string }>(
-    "SELECT id FROM workflow_runs WHERE parentStepId = ?",
-    [parentStepId],
+    "SELECT id FROM workflow_runs WHERE parentStepId = ? AND parentStepAttempt = ?",
+    [parentStepId, attempt],
   );
   return row?.id ?? null;
 }
 
+/**
+ * True while `attempt` of the step is executing in a live run: the step is
+ * `running` with that `retryCount`. A child run is created only then, so a
+ * cancelled run, a step another attempt moved on, or a step already parked
+ * never gets a new child.
+ */
+export async function isParentStepAttemptCurrent(
+  parentStepId: string,
+  attempt: number,
+): Promise<boolean> {
+  const row = await getDbClient().get<{ found: number }>(
+    `SELECT 1 AS found
+       FROM workflow_run_steps s
+       JOIN workflow_runs r ON r.id = s.runId
+      WHERE s.id = ? AND s.status = 'running' AND s.retryCount = ?
+        AND r.status IN ('running', 'waiting')`,
+    [parentStepId, attempt],
+  );
+  return row != null;
+}
+
+/**
+ * `sub-workflow` steps left `running` in a live run: each is its node's latest
+ * row, so a row a newer one superseded is not listed. The caller skips the
+ * ones this process is still executing.
+ */
+export async function getRunningSubWorkflowSteps(): Promise<
+  Array<{ stepId: string; runId: string; nodeId: string }>
+> {
+  return getDbClient().query<{ stepId: string; runId: string; nodeId: string }>(
+    `SELECT s.id AS stepId, s.runId AS runId, s.nodeId AS nodeId
+       FROM workflow_run_steps s
+       JOIN workflow_runs r ON r.id = s.runId
+      WHERE s.status = 'running' AND s.nodeType = 'sub-workflow'
+        AND r.status IN ('running', 'waiting')
+        AND s.rowid = (
+          SELECT MAX(rowid) FROM workflow_run_steps
+           WHERE runId = s.runId AND nodeId = s.nodeId
+        )`,
+  );
+}
+
 /** Where a child run came from: the `sub-workflow` step that started it and that step's run. */
 export type WorkflowRunParent = {
   runId: string;
@@ -65,12 +111,13 @@ export async function getWorkflowRunLineage(runId: string, maxDepth: number): Pr
   return rows.map((row) => row.workflowId);
 }
 
-/** Waiting `sub-workflow` steps whose child run is terminal or deleted. */
+/** Waiting `sub-workflow` steps whose current attempt's child run is terminal or deleted. */
 export async function getSettledChildRunParentSteps(): Promise<string[]> {
   const rows = await getDbClient().query<{ id: string }>(
     `SELECT s.id
        FROM workflow_run_steps s
-       LEFT JOIN workflow_runs c ON c.parentStepId = s.id
+       LEFT JOIN workflow_runs c
+         ON c.parentStepId = s.id AND c.parentStepAttempt = s.retryCount
       WHERE s.status = 'waiting' AND s.nodeType = 'sub-workflow'
         AND (c.id IS NULL OR c.status IN ('completed', 'failed', 'cancelled', 'skipped'))`,
   );