@desplega.ai/agent-swarm 2.5.2 → 2.5.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@desplega.ai/agent-swarm",
-  "version": "2.5.2",
+  "version": "2.5.3",
   "description": "agent-swarm.dev — an open-source operating system for AI work: a lead agent breaks goals into tasks, routes them to specialized workers such as Claude Code or Codex, runs each worker in an isolated container, and preserves shared memory, tools, schedules, and review gates so delegated work compounds across sessions.",
   "keywords": [
     "agent-swarm.dev",
@@ -180,8 +180,8 @@
     "@desplega/model-catalog": "workspace:*",
     "@desplega/model-routing": "workspace:*",
     "@faker-js/faker": "^10.4.0",
-    "@opencode/plugin": "2.1.3",
-    "@opencode/sdk": "2.1.3",
+    "@opencode/plugin": "2.1.4",
+    "@opencode/sdk": "2.1.4",
     "@oxlint/plugins": "1.78.0",
     "@types/bun": "latest",
     "dependency-cruiser": "^18.0.0",
@@ -202,7 +202,7 @@
     "@agentclientprotocol/sdk": "2.0.1",
     "@ai-sdk/openai": "^3.0.41",
     "@anthropic-ai/claude-agent-sdk": "0.3.309",
-    "@anthropic-ai/sdk": "^1.1.0",
+    "@anthropic-ai/sdk": "^1.2.0",
     "@asteasolutions/zod-to-openapi": "^8.0.0",
     "@aws-sdk/client-bedrock": "3.1048.0",
     "@chat-adapter/discord": "4.41.1",

package/src/be/approval-config-question.ts

@@ -0,0 +1,389 @@
+/**
+ * HITL `config` questions: ask a person to set one swarm config key (a secret
+ * or a plain value) from the dashboard. The answer is written to
+ * `swarm_config` by the respond handler, and only a {@link ConfigResult} is
+ * ever stored on the request or sent onward, so a secret never reaches the
+ * agent, the workflow run, the follow-up task or any notification.
+ */
+import * as z from "zod";
+import { getDbClient } from "./db";
+import { upsertSwarmConfigWithPolicyMirror } from "./multi-runtime";
+import {
+  internalConfigKeyError,
+  isApiOnlyConfigKey,
+  isInternalConfigKey,
+  isReservedConfigKey,
+  reservedKeyError,
+  validateConfigEntry,
+} from "./swarm-config-guard";
+
+export const ConfigQuestionSettingsSchema = z.object({
+  key: z
+    .string()
+    .min(1)
+    .max(255)
+    .regex(/^\S+$/, "must not contain whitespace")
+    .describe("The swarm config key to set, e.g. BITBUCKET_TOKEN"),
+  scope: z.enum(["global", "agent", "repo"]).describe("Config scope the value is written to"),
+  scopeId: z
+    .string()
+    .min(1)
+    .optional()
+    .describe(
+      "Agent or repo id for agent/repo scope. From request-human-input, agent scope defaults to the calling agent; pass it explicitly when asking on behalf of another agent.",
+    ),
+  isSecret: z
+    .boolean()
+    .optional()
+    .describe(
+      "Store encrypted and never show the value (default true). An existing secret row always stays secret.",
+    ),
+  helpUrl: z
+    .string()
+    .url()
+    .refine((url) => /^https?:\/\//i.test(url), "must be an http(s) URL")
+    .optional()
+    .describe("Link shown next to the field, e.g. where to create the token"),
+  options: z
+    .array(
+      z.object({
+        value: z.string(),
+        label: z.string(),
+        description: z.string().optional(),
+      }),
+    )
+    .optional()
+    .describe("Allowed values for a non-secret key, rendered as a choice"),
+  defaultValue: z.string().optional().describe("Prefilled value for a non-secret key"),
+});
+
+export type ConfigQuestionSettings = z.infer<typeof ConfigQuestionSettingsSchema>;
+
+/** Settings after create-time normalization: `isSecret` is always resolved. */
+export type NormalizedConfigSettings = ConfigQuestionSettings & { isSecret: boolean };
+
+/** What the dashboard sends for a config question (D6). */
+export const ConfigAnswerSchema = z.discriminatedUnion("action", [
+  z.object({ action: z.literal("set"), value: z.string() }),
+  z.object({ action: z.literal("keep") }),
+  z.object({ action: z.literal("skip") }),
+]);
+export type ConfigAnswer = z.infer<typeof ConfigAnswerSchema>;
+
+/** The only form of a config answer that is ever stored or sent (D7). */
+export const ConfigResultSchema = z.object({
+  key: z.string(),
+  scope: z.enum(["global", "agent", "repo"]),
+  scopeId: z.string().nullable(),
+  isSecret: z.boolean(),
+  status: z.enum(["set", "kept", "skipped"]),
+  updatedAt: z.string().nullable(),
+  value: z.string().optional(),
+});
+export type ConfigResult = z.infer<typeof ConfigResultSchema>;
+
+/** Live state of the key a config question targets (never persisted). */
+export const ConfigStateSchema = z.object({
+  exists: z.boolean(),
+  isSecret: z.boolean(),
+  updatedAt: z.string().nullable(),
+  value: z.string().optional().describe("Current value; present only for non-secret rows"),
+});
+export type ConfigState = z.infer<typeof ConfigStateSchema>;
+
+type ConfigQuestionInput = {
+  id: string;
+  type: string;
+  label?: string;
+  required?: boolean;
+  config?: ConfigQuestionSettings;
+};
+
+export type NormalizedConfigQuestion<Q extends ConfigQuestionInput> = Omit<Q, "config"> & {
+  label: string;
+  required: boolean;
+  config: NormalizedConfigSettings;
+};
+
+type ApproversLike = { policy: unknown };
+
+interface ConfigRowMeta {
+  isSecret: boolean;
+  updatedAt: string;
+  envPath: string | null;
+  description: string | null;
+  value?: string;
+}
+
+/** The exact `(scope, scopeId, key)` row, without decrypting anything. */
+async function readConfigRow(
+  settings: Pick<ConfigQuestionSettings, "scope" | "scopeId" | "key">,
+): Promise<ConfigRowMeta | null> {
+  const scopeId = settings.scope === "global" ? null : (settings.scopeId ?? null);
+  const row = await getDbClient().get<{
+    isSecret: number;
+    lastUpdatedAt: string;
+    envPath: string | null;
+    description: string | null;
+    plainValue: string | null;
+  }>(
+    `SELECT isSecret, lastUpdatedAt, envPath, description,
+            CASE WHEN isSecret = 1 THEN NULL ELSE value END AS plainValue
+       FROM swarm_config
+      WHERE scope = ? AND ${scopeId === null ? "scopeId IS NULL" : "scopeId = ?"} AND key = ?`,
+    scopeId === null ? [settings.scope, settings.key] : [settings.scope, scopeId, settings.key],
+  );
+  if (!row) return null;
+  // API-only keys are never readable over HTTP, so they count as secret here.
+  const isSecret = row.isSecret === 1 || isApiOnlyConfigKey(settings.key);
+  return {
+    isSecret,
+    updatedAt: row.lastUpdatedAt,
+    envPath: row.envPath,
+    description: row.description,
+    ...(isSecret || row.plainValue === null ? {} : { value: row.plainValue }),
+  };
+}
+
+export async function readConfigState(settings: ConfigQuestionSettings): Promise<ConfigState> {
+  const row = await readConfigRow(settings);
+  if (!row) return { exists: false, isSecret: settings.isSecret !== false, updatedAt: null };
+  const isSecret = row.isSecret || settings.isSecret !== false;
+  return {
+    exists: true,
+    isSecret,
+    updatedAt: row.updatedAt,
+    ...(!isSecret && row.value !== undefined ? { value: row.value } : {}),
+  };
+}
+
+/**
+ * Create-time rules for one config question (D2, D3, D5). Defaults `label` to
+ * the key and `required` to true, resolves the effective `isSecret` against
+ * the live row, and rejects keys and shapes the config API would refuse.
+ */
+export async function normalizeConfigQuestion<Q extends ConfigQuestionInput>(
+  question: Q,
+  ctx: { approvers: ApproversLike; callerAgentId?: string },
+): Promise<{ ok: true; question: NormalizedConfigQuestion<Q> } | { ok: false; error: string }> {
+  const fail = (reason: string) => ({
+    ok: false as const,
+    error: `config question "${question.id}": ${reason}`,
+  });
+  const parsed = ConfigQuestionSettingsSchema.safeParse(question.config);
+  if (!parsed.success) {
+    const issue = parsed.error.issues[0];
+    const path = issue?.path.length ? `config.${issue.path.map(String).join(".")}` : "config";
+    return fail(`${path}: ${issue?.message ?? "invalid"}`);
+  }
+  if (ctx.approvers.policy !== "any") {
+    return fail('a config question needs approvers.policy "any" (a config value has one author)');
+  }
+
+  const settings = { ...parsed.data };
+  if (settings.scope === "agent" && !settings.scopeId && ctx.callerAgentId) {
+    settings.scopeId = ctx.callerAgentId;
+  }
+  if (settings.scope === "global" && settings.scopeId) {
+    return fail("global scope must not have scopeId");
+  }
+  if (settings.scope !== "global" && !settings.scopeId) {
+    return fail(`${settings.scope} scope requires scopeId`);
+  }
+  if (isReservedConfigKey(settings.key)) return fail(reservedKeyError(settings.key).message);
+  if (isInternalConfigKey(settings.key)) return fail(internalConfigKeyError(settings.key).message);
+
+  const row = await readConfigRow(settings);
+  const isSecret =
+    settings.isSecret !== false || row?.isSecret === true || isApiOnlyConfigKey(settings.key);
+  if (isSecret && (settings.options || settings.defaultValue !== undefined)) {
+    return fail(
+      "options and defaultValue are only allowed when isSecret is false (and the key is not already stored as a secret)",
+    );
+  }
+  if (settings.options?.length === 0) return fail("options must not be empty");
+  if (
+    settings.options &&
+    settings.defaultValue !== undefined &&
+    !settings.options.some((option) => option.value === settings.defaultValue)
+  ) {
+    return fail("defaultValue must be one of options");
+  }
+
+  const label = question.label?.trim() ? question.label : settings.key;
+  return {
+    ok: true,
+    question: {
+      ...question,
+      label,
+      required: question.required ?? true,
+      config: { ...settings, isSecret },
+    },
+  };
+}
+
+type AnyQuestion = { id: string; type: string; label?: string; config?: ConfigQuestionSettings };
+
+/**
+ * Normalizes every config question in a list and checks that the others carry
+ * a label and no `config` block. Non-config questions pass through unchanged.
+ */
+export async function normalizeApprovalQuestions<Q extends AnyQuestion>(
+  questions: Q[],
+  ctx: { approvers: ApproversLike; callerAgentId?: string },
+): Promise<
+  | { ok: true; questions: ((Q & { label: string }) | NormalizedConfigQuestion<Q>)[] }
+  | { ok: false; error: string }
+> {
+  const out: ((Q & { label: string }) | NormalizedConfigQuestion<Q>)[] = [];
+  for (const question of questions) {
+    if (question.type !== "config") {
+      if (question.config !== undefined) {
+        return {
+          ok: false,
+          error: `question "${question.id}": the config block is only valid on type "config"`,
+        };
+      }
+      if (typeof question.label !== "string") {
+        return { ok: false, error: `question "${question.id}": label is required` };
+      }
+      out.push({ ...question, label: question.label });
+      continue;
+    }
+    const normalized = await normalizeConfigQuestion(question, ctx);
+    if (!normalized.ok) return normalized;
+    out.push(normalized.question);
+  }
+  return { ok: true, questions: out };
+}
+
+/** A stored config question, as read back from `approval_requests.questions`. */
+export type StoredConfigQuestion = {
+  id: string;
+  type: "config";
+  label: string;
+  required?: boolean;
+  config: NormalizedConfigSettings;
+};
+
+export function isConfigQuestion(question: {
+  type: string;
+  config?: unknown;
+}): question is StoredConfigQuestion {
+  return question.type === "config" && typeof question.config === "object" && !!question.config;
+}
+
+/**
+ * Validates one raw answer against D6 and the config API's rules. Errors name
+ * the question and the rule, never the value.
+ */
+export function parseConfigAnswer(
+  question: StoredConfigQuestion,
+  raw: unknown,
+  state: ConfigState,
+): { ok: true; answer: ConfigAnswer } | { ok: false; error: string } {
+  const fail = (reason: string) => ({
+    ok: false as const,
+    error: `config question "${question.id}": ${reason}`,
+  });
+  const required = question.required !== false;
+  if (raw === undefined || raw === null) {
+    return required ? fail("an answer is required") : { ok: true, answer: { action: "skip" } };
+  }
+  const parsed = ConfigAnswerSchema.safeParse(raw);
+  if (!parsed.success) {
+    return fail(
+      'answer must be { action: "set", value } , { action: "keep" } or { action: "skip" }',
+    );
+  }
+  const answer = parsed.data;
+  if (answer.action === "keep") {
+    return state.exists ? { ok: true, answer } : fail("cannot keep a key that is not set");
+  }
+  if (answer.action === "skip") {
+    return required ? fail("a required question cannot be skipped") : { ok: true, answer };
+  }
+  if (answer.value.trim().length === 0) return fail("value must not be empty");
+  const { config } = question;
+  const isSecret = config.isSecret || state.isSecret;
+  if (!isSecret && config.options && !config.options.some((o) => o.value === answer.value)) {
+    return fail("value must be one of options");
+  }
+  const error = validateConfigEntry({
+    scope: config.scope,
+    scopeId: config.scopeId ?? null,
+    key: config.key,
+    value: answer.value,
+  });
+  if (error) return fail(isSecret ? `value rejected by ${config.key} validation` : error);
+  return { ok: true, answer };
+}
+
+function result(
+  question: StoredConfigQuestion,
+  status: ConfigResult["status"],
+  isSecret: boolean,
+  updatedAt: string | null,
+  value?: string,
+): ConfigResult {
+  const { key, scope, scopeId } = question.config;
+  return {
+    key,
+    scope,
+    scopeId: scope === "global" ? null : (scopeId ?? null),
+    isSecret,
+    status,
+    updatedAt,
+    ...(!isSecret && value !== undefined ? { value } : {}),
+  };
+}
+
+export function skippedConfigResult(question: StoredConfigQuestion): ConfigResult {
+  return result(question, "skipped", question.config.isSecret, null);
+}
+
+/** `keep`: nothing is written. Null when the row disappeared since validation. */
+export async function keptConfigResult(
+  question: StoredConfigQuestion,
+): Promise<ConfigResult | null> {
+  const row = await readConfigRow(question.config);
+  if (!row) return null;
+  const isSecret = question.config.isSecret || row.isSecret;
+  return result(question, "kept", isSecret, row.updatedAt, row.value);
+}
+
+/**
+ * `set`: writes the value inside the caller's transaction. Carries the row's
+ * `envPath` and `description` forward (the upsert would null them) and keeps
+ * an existing secret secret. The caller runs the HTTP side effects after
+ * commit.
+ */
+export async function applyConfigAnswer(
+  question: StoredConfigQuestion,
+  value: string,
+): Promise<ConfigResult> {
+  const { config } = question;
+  const existing = await readConfigRow(config);
+  const isSecret = config.isSecret || existing?.isSecret === true;
+  const written = await upsertSwarmConfigWithPolicyMirror({
+    scope: config.scope,
+    scopeId: config.scope === "global" ? null : (config.scopeId ?? null),
+    key: config.key,
+    value,
+    isSecret,
+    envPath: existing?.envPath ?? null,
+    description: existing?.description ?? null,
+  });
+  return result(question, "set", isSecret, written.lastUpdatedAt, value);
+}
+
+/** One line for the hitl-follow-up task text. Never carries a secret. */
+export function formatConfigResult(value: unknown): string | null {
+  const parsed = ConfigResultSchema.safeParse(value);
+  if (!parsed.success) return null;
+  const r = parsed.data;
+  const where = `${r.scope}${r.scopeId ? `:${r.scopeId}` : ""}`;
+  const updated = r.updatedAt ? `, updated ${r.updatedAt}` : "";
+  const shown = !r.isSecret && r.value !== undefined ? ` = ${r.value}` : "";
+  return `${r.key} (${where}, ${r.isSecret ? "secret" : "plain"}): ${r.status}${updated}${shown}`;
+}

package/src/be/automation-preflight.ts

@@ -345,6 +345,29 @@ function utcDayBounds(now: Date): { start: string; end: string } {
   return { start: start.toISOString(), end: new Date(start.getTime() + 86_400_000).toISOString() };
 }
 
+/**
+ * True when `runId` is the workflow's only setup-failure run so far this UTC
+ * day, top-level or child. Call it in the transaction that inserted `runId`:
+ * transactions serialize on the write lock, so of several concurrent failures
+ * exactly one sees no other and alerts.
+ */
+export async function isFirstWorkflowPreflightFailureToday(
+  workflowId: string,
+  runId: string,
+  now: Date = new Date(),
+): Promise<boolean> {
+  const bounds = utcDayBounds(now);
+  const row = await getDbClient().get<{ found: number }>(
+    `SELECT 1 AS found FROM workflow_runs
+     WHERE workflowId = ? AND id != ? AND status = 'failed'
+       AND error LIKE 'needs_setup:%'
+       AND startedAt >= ? AND startedAt < ?
+     LIMIT 1`,
+    [workflowId, runId, bounds.start, bounds.end],
+  );
+  return row == null;
+}
+
 /** Record at most one copy of the same setup failure on a schedule per UTC day. */
 export async function recordSchedulePreflightFailure(
   scheduleId: string,
@@ -376,7 +399,11 @@ export async function recordSchedulePreflightFailure(
   });
 }
 
-/** Create and finish at most one failed preflight run per workflow and UTC day. */
+/**
+ * Create and finish at most one failed top-level preflight run per workflow
+ * and UTC day. `recorded` is true when the caller should alert: this call
+ * inserted the run and no child failure run of the workflow came first today.
+ */
 export async function recordWorkflowPreflightFailure(input: {
   workflowId: string;
   triggerType: "schedule" | "manual" | "event" | "api";
@@ -388,9 +415,11 @@ export async function recordWorkflowPreflightFailure(input: {
   const now = input.now ?? new Date();
   const bounds = utcDayBounds(now);
   return await getDbClient().transaction(async (tx) => {
+    // Child runs record their own linked failure (`startWorkflowExecution`);
+    // a top-level trigger never reuses one.
     const existing = await tx.get<{ id: string }>(
       `SELECT id FROM workflow_runs
-       WHERE workflowId = ? AND status = 'failed'
+       WHERE workflowId = ? AND status = 'failed' AND parentStepId IS NULL
          AND error LIKE 'needs_setup:%'
          AND startedAt >= ? AND startedAt < ?
        ORDER BY startedAt ASC LIMIT 1`,
@@ -417,6 +446,11 @@ export async function recordWorkflowPreflightFailure(input: {
         timestamp,
       ],
     );
-    return { runId, recorded: true };
+    // Claimed in this transaction, which also sees every child failure run
+    // committed before it: concurrent failures alert exactly once a day.
+    return {
+      runId,
+      recorded: await isFirstWorkflowPreflightFailureToday(input.workflowId, runId, now),
+    };
   });
 }

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

@@ -16,8 +16,13 @@ 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 sessions v2 source filter). */
+  /** 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. */
@@ -50,13 +55,17 @@ export interface SessionFilters {
 
 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'
@@ -100,6 +109,14 @@ export function sessionRootFilter(opts: SessionFilters = {}): SqlFragment {
   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({
@@ -152,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.
@@ -162,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") {
@@ -182,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
@@ -341,7 +395,7 @@ export interface SessionTree {
 export async function getSessionTree(
   actor: { kind: "bypass" } | { kind: "user"; userId: string | null },
   now?: string,
-  opts: { mine?: boolean; hideSource?: 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.
@@ -373,6 +427,7 @@ export async function getSessionTree(
     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]) => {
@@ -383,7 +438,7 @@ export async function getSessionTree(
   };
   for (const row of rows) {
     sources.set(row.source, (sources.get(row.source) ?? 0) + 1);
-    if (hidden.has(row.source)) continue;
+    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}/`);
@@ -425,7 +480,10 @@ const UNREAD_CURSOR = "1970-01-01T00:00:00.000Z";
  */
 export async function triageSessionList(
   userId: string,
-  filters: Pick<SessionFilters, "triage" | "noGroup" | "groupKey" | "mine" | "hideSource" | "now">,
+  filters: Pick<
+    SessionFilters,
+    "triage" | "noGroup" | "groupKey" | "mine" | "hideSource" | "showSource" | "now"
+  >,
   action: SessionListTriage,
 ): Promise<number> {
   const now = filters.now ?? new Date().toISOString();