@desplega.ai/agent-swarm 2.2.0 → 2.4.0

package/src/be/db.ts

@@ -195,6 +195,7 @@ import {
 } from "./db/context-versions";
 import { clearAgentModelProfileOnOverrideChange } from "./db/model-profiles";
 import { getDb, getDbClient } from "./db/runtime";
+import { type SessionViewer, sessionViewerCondition } from "./db/session-visibility";
 import { classifyTaskHumanFree, reclassifyTaskHumanFree } from "./db/tasks/human-free";
 import {
   type AgentTaskRow,
@@ -203,6 +204,7 @@ import {
   findExistingLinearTrackerContextWork,
   getTaskById,
   getTasksByAgentId,
+  readableSessionCondition,
   rowToAgentTask,
   rowToAgentTaskSummary,
 } from "./db/tasks/read";
@@ -1731,7 +1733,9 @@ export async function moveAssetKey(input: {
   id: string;
   key: string;
   changedBy?: string;
-}): Promise<boolean> {
+  /** Task moves only: descendant task ids the caller already authorized to move with the task. */
+  descendantTaskIds?: readonly string[];
+}): Promise<false | { movedTaskIds?: string[] }> {
   const key = normalizeAssetKey(input.key);
   // auditAssetKeys stays sync (shared with the boot audit); run it inside a
   // client transaction so this request-path read cannot observe another
@@ -1746,7 +1750,7 @@ export async function moveAssetKey(input: {
   }
   const previousKey = await currentAssetKey(input.entityType, input.id);
   if (!previousKey) return false;
-  if (previousKey === key) return true;
+  if (previousKey === key && input.entityType !== "task") return {};
   if (input.entityType === "file") {
     const mapping = await getAssetKeyMapping(input.id);
     if (mapping?.sourceEntityType === "task-attachment") {
@@ -1757,48 +1761,64 @@ export async function moveAssetKey(input: {
   }
   const now = new Date().toISOString();
 
-  await getDbClient().transaction(async (tx) => {
+  return getDbClient().transaction(async (tx) => {
     switch (input.entityType) {
       case "task": {
-        const mappedFiles = await tx.query<{ id: string; key: string }>(
-          `SELECT DISTINCT m.id, m."key" AS key
+        const root = await getTaskById(input.id);
+        if (!root) return false;
+        const tasks = [root];
+        for (const id of input.descendantTaskIds ?? []) {
+          const task = id === root.id ? null : await getTaskById(id);
+          if (task) tasks.push(task);
+        }
+        const movedTaskIds: string[] = [];
+        for (const task of tasks) {
+          if (task.key === key) continue;
+          // A file shared with another task keeps the namespace of the task whose attachment
+          // sources its mapping. Mappings with no attachment source follow any attaching task.
+          const mappedFiles = await tx.query<{ id: string; key: string }>(
+            `SELECT DISTINCT m.id, m."key" AS key
              FROM asset_key_mappings m
              JOIN task_attachments a
                ON m.provider_id = COALESCE(NULLIF(a.provider_id, ''), 'agent-fs')
               AND m.provider_org_id = COALESCE(a.agent_fs_org_id, '')
               AND m.provider_drive_id = COALESCE(a.agent_fs_drive_id, '')
               AND m.provider_key = COALESCE(NULLIF(a.provider_key, ''), a.path)
-             WHERE a.task_id = ?`,
-          [input.id],
-        );
-        await tx.run(
-          'UPDATE agent_tasks SET "key" = ?, lastUpdatedAt = ?, updated_by = ? WHERE id = ?',
-          [key, now, input.changedBy ?? null, input.id],
-        );
-        await tx.run(
-          `UPDATE asset_key_mappings
-           SET "key" = ?, updated_at = ?, updated_by = ?
-           WHERE EXISTS (
-             SELECT 1 FROM task_attachments a
              WHERE a.task_id = ?
-               AND asset_key_mappings.provider_id = COALESCE(NULLIF(a.provider_id, ''), 'agent-fs')
-               AND asset_key_mappings.provider_org_id = COALESCE(a.agent_fs_org_id, '')
-               AND asset_key_mappings.provider_drive_id = COALESCE(a.agent_fs_drive_id, '')
-               AND asset_key_mappings.provider_key = COALESCE(NULLIF(a.provider_key, ''), a.path)
-           )`,
-          [key, now, input.changedBy ?? null, input.id],
-        );
-        for (const mapping of mappedFiles) {
-          if (mapping.key === key) continue;
+               AND (m.source_entity_type IS NOT 'task-attachment'
+                 OR m.source_entity_id IN (SELECT id FROM task_attachments WHERE task_id = ?))`,
+            [task.id, task.id],
+          );
+          // The namespace is metadata, and lastUpdatedAt tracks task activity, as in updateTaskTitle.
+          await tx.run('UPDATE agent_tasks SET "key" = ?, updated_by = ? WHERE id = ?', [
+            key,
+            input.changedBy ?? null,
+            task.id,
+          ]);
+          for (const mapping of mappedFiles) {
+            if (mapping.key === key) continue;
+            await tx.run(
+              'UPDATE asset_key_mappings SET "key" = ?, updated_at = ?, updated_by = ? WHERE id = ?',
+              [key, now, input.changedBy ?? null, mapping.id],
+            );
+            await insertAssetKeyHistory({
+              entityType: "file",
+              entityId: mapping.id,
+              previousKey: mapping.key,
+              newKey: key,
+              changedBy: input.changedBy,
+            });
+          }
           await insertAssetKeyHistory({
-            entityType: "file",
-            entityId: mapping.id,
-            previousKey: mapping.key,
+            entityType: "task",
+            entityId: task.id,
+            previousKey: task.key,
             newKey: key,
             changedBy: input.changedBy,
           });
+          movedTaskIds.push(task.id);
         }
-        break;
+        return { movedTaskIds };
       }
       case "workflow":
         await tx.run(
@@ -1849,8 +1869,8 @@ export async function moveAssetKey(input: {
       newKey: key,
       changedBy: input.changedBy,
     });
+    return {};
   });
-  return true;
 }
 
 export async function deleteTaskAttachment(id: string): Promise<boolean> {
@@ -2063,13 +2083,17 @@ export async function getPendingSteeringForTask(taskId: string): Promise<Steerin
   return await getSteeringMessagesForTask(taskId, { status: "pending" });
 }
 
-export async function getPendingSteeringForAgent(agentId: string): Promise<SteeringMessage[]> {
+export async function getPendingSteeringForAgent(
+  agentId: string,
+  readableBy?: { userId: string | null },
+): Promise<SteeringMessage[]> {
+  const readable = readableBy ? readableSessionCondition(readableBy.userId, "t.id") : undefined;
   const rows = await getDbClient().query<TaskSteeringMessageRow>(
     `${STEERING_MESSAGE_SELECT}
        JOIN agent_tasks t ON t.id = m.task_id
-       WHERE t.agentId = ? AND m.status = 'pending'
+       WHERE t.agentId = ? AND m.status = 'pending'${readable ? ` AND ${readable.sql}` : ""}
        ORDER BY m.created_at ASC, m.rowid ASC`,
-    [agentId],
+    [agentId, ...(readable?.params ?? [])],
   );
   return rows.map(rowToSteeringMessage);
 }
@@ -2167,27 +2191,33 @@ export async function hasPendingSteering(taskId: string): Promise<boolean> {
 // Combined Queries (Agent with Tasks)
 // ============================================================================
 
-export async function getAgentWithTasks(id: string): Promise<AgentWithTasks | null> {
+export async function getAgentWithTasks(
+  id: string,
+  readableBy?: { userId: string | null },
+): Promise<AgentWithTasks | null> {
   return await getDbClient().transaction(
     async () => {
       const agent = await getAgentById(id);
       if (!agent) return null;
 
-      const tasks = await getTasksByAgentId(id);
+      const tasks = await getTasksByAgentId(id, readableBy);
       return { ...agent, tasks };
     },
     { readOnly: true },
   );
 }
 
-export async function getAllAgentsWithTasks(opts?: { slim?: boolean }): Promise<AgentWithTasks[]> {
+export async function getAllAgentsWithTasks(opts?: {
+  slim?: boolean;
+  readableBy?: { userId: string | null };
+}): Promise<AgentWithTasks[]> {
   return await getDbClient().transaction(
     async () => {
       const agents = await getAllAgents({ slim: opts?.slim ?? false });
       return await Promise.all(
         agents.map(async (agent) => ({
           ...agent,
-          tasks: await getTasksByAgentId(agent.id),
+          tasks: await getTasksByAgentId(agent.id, opts?.readableBy),
         })),
       );
     },
@@ -2250,10 +2280,16 @@ export async function createLogEntry(entry: {
   return rowToAgentLog(row);
 }
 
-export async function getLogsByAgentId(agentId: string): Promise<AgentLog[]> {
+export async function getLogsByAgentId(
+  agentId: string,
+  readableBy?: { userId: string | null },
+): Promise<AgentLog[]> {
+  const readable = readableBy
+    ? readableSessionCondition(readableBy.userId, "agent_log.taskId", { nullable: true })
+    : undefined;
   const rows = await getDbClient().query<AgentLogRow>(
-    "SELECT * FROM agent_log WHERE agentId = ? ORDER BY createdAt DESC",
-    [agentId],
+    `SELECT * FROM agent_log WHERE agentId = ?${readable ? ` AND ${readable.sql}` : ""} ORDER BY createdAt DESC`,
+    [agentId, ...(readable?.params ?? [])],
   );
   return rows.map(rowToAgentLog);
 }
@@ -2297,16 +2333,24 @@ export async function getLogsByEventType(eventType: AgentLogEventType): Promise<
   return rows.map(rowToAgentLog);
 }
 
-export async function getAllLogs(limit?: number): Promise<AgentLog[]> {
+export async function getAllLogs(
+  limit?: number,
+  readableBy?: { userId: string | null },
+): Promise<AgentLog[]> {
+  const readable = readableBy
+    ? readableSessionCondition(readableBy.userId, "agent_log.taskId", { nullable: true })
+    : undefined;
+  const readableParams = readable?.params ?? [];
   if (limit) {
     const rows = await getDbClient().query<AgentLogRow>(
-      "SELECT * FROM agent_log WHERE eventType != 'agent_status_change' ORDER BY createdAt DESC LIMIT ?",
-      [limit],
+      `SELECT * FROM agent_log WHERE eventType != 'agent_status_change'${readable ? ` AND ${readable.sql}` : ""} ORDER BY createdAt DESC LIMIT ?`,
+      [...readableParams, limit],
     );
     return rows.map(rowToAgentLog);
   }
   const rows = await getDbClient().query<AgentLogRow>(
-    "SELECT * FROM agent_log ORDER BY createdAt DESC",
+    `SELECT * FROM agent_log${readable ? ` WHERE ${readable.sql}` : ""} ORDER BY createdAt DESC`,
+    readableParams,
   );
   return rows.map(rowToAgentLog);
 }
@@ -5802,8 +5846,13 @@ export interface ConcurrentContext {
  * Returns processing inbox messages, recent task delegations by leads,
  * and currently active (in-progress) tasks across the swarm.
  */
-export async function getConcurrentContext(): Promise<ConcurrentContext> {
+export async function getConcurrentContext(readableBy?: {
+  userId: string | null;
+}): Promise<ConcurrentContext> {
   const client = getDbClient();
+  const readable = readableBy ? readableSessionCondition(readableBy.userId, "t.id") : undefined;
+  const readableSql = readable ? ` AND ${readable.sql}` : "";
+  const readableParams = readable?.params ?? [];
 
   // 1. Inbox messages currently being processed (status = 'processing')
   const processingInboxMessages = await client.query<{
@@ -5832,9 +5881,9 @@ export async function getConcurrentContext(): Promise<ConcurrentContext> {
        FROM agent_tasks t
        LEFT JOIN agents a ON t.agentId = a.id
        WHERE t.createdAt > ?
-         AND t.creatorAgentId IN (SELECT id FROM agents WHERE isLead = 1)
+         AND t.creatorAgentId IN (SELECT id FROM agents WHERE isLead = 1)${readableSql}
        ORDER BY t.createdAt DESC`,
-    [fiveMinutesAgo],
+    [fiveMinutesAgo, ...readableParams],
   );
 
   // 3. Currently in-progress tasks across the swarm
@@ -5850,8 +5899,9 @@ export async function getConcurrentContext(): Promise<ConcurrentContext> {
     `SELECT t.id, t.task, t.agentId, a.name as agentName, t.status, t.createdAt, t.progress
        FROM agent_tasks t
        LEFT JOIN agents a ON t.agentId = a.id
-       WHERE t.status = 'in_progress'
+       WHERE t.status = 'in_progress'${readableSql}
        ORDER BY t.createdAt DESC`,
+    readableParams,
   );
 
   return {
@@ -7139,15 +7189,27 @@ export async function deleteActiveSessionById(id: string): Promise<boolean> {
   return result.changes > 0;
 }
 
-export async function getActiveSessions(agentId?: string): Promise<ActiveSession[]> {
+export async function getActiveSessions(
+  agentId?: string,
+  readableBy?: { userId: string | null },
+): Promise<ActiveSession[]> {
+  const conditions: string[] = [];
+  const params: string[] = [];
   if (agentId) {
-    return await getDbClient().query<ActiveSession>(
-      "SELECT * FROM active_sessions WHERE agentId = ? ORDER BY startedAt DESC",
-      [agentId],
-    );
+    conditions.push("agentId = ?");
+    params.push(agentId);
   }
+  if (readableBy) {
+    const readable = readableSessionCondition(readableBy.userId, "active_sessions.taskId", {
+      nullable: true,
+    });
+    conditions.push(readable.sql);
+    params.push(...readable.params);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
   return await getDbClient().query<ActiveSession>(
-    "SELECT * FROM active_sessions ORDER BY startedAt DESC",
+    `SELECT * FROM active_sessions ${where} ORDER BY startedAt DESC`,
+    params,
   );
 }
 
@@ -12513,6 +12575,7 @@ interface InboxItemStateRow {
   dismissedAt: string | null;
   doneAt: string | null;
   readAt: string | null;
+  lastReadAt: string | null;
   createdAt: string;
   lastUpdatedAt: string;
 }
@@ -12528,6 +12591,7 @@ function rowToInboxItemState(row: InboxItemStateRow): InboxItemState {
     dismissedAt: row.dismissedAt ?? undefined,
     doneAt: row.doneAt ?? undefined,
     readAt: row.readAt ?? undefined,
+    lastReadAt: row.lastReadAt ?? undefined,
     createdAt: row.createdAt,
     lastUpdatedAt: row.lastUpdatedAt,
   };
@@ -12568,6 +12632,7 @@ export async function upsertInboxState(opts: {
   doneAt?: string;
   /** First-viewed timestamp. Sticky: once set, later calls never clear or move it. */
   readAt?: string;
+  lastReadAt?: string | null;
 }): Promise<InboxItemState> {
   const now = new Date().toISOString();
   // Auto-derive timestamps from status when not explicitly provided.
@@ -12579,14 +12644,15 @@ export async function upsertInboxState(opts: {
   // SQLite upsert via UNIQUE(userId, itemType, itemId). readAt is sticky: the
   // first non-null value written wins on every subsequent conflict.
   const row = await getDbClient().get<InboxItemStateRow>(
-    `INSERT INTO inbox_item_state (userId, itemType, itemId, status, snoozeUntil, dismissedAt, doneAt, readAt, createdAt, lastUpdatedAt)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `INSERT INTO inbox_item_state (userId, itemType, itemId, status, snoozeUntil, dismissedAt, doneAt, readAt, lastReadAt, createdAt, lastUpdatedAt)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
        ON CONFLICT(userId, itemType, itemId) DO UPDATE SET
          status = excluded.status,
          snoozeUntil = excluded.snoozeUntil,
          dismissedAt = excluded.dismissedAt,
          doneAt = excluded.doneAt,
          readAt = COALESCE(inbox_item_state.readAt, excluded.readAt),
+         lastReadAt = CASE WHEN ? THEN excluded.lastReadAt ELSE inbox_item_state.lastReadAt END,
          lastUpdatedAt = excluded.lastUpdatedAt
        RETURNING *`,
     [
@@ -12598,8 +12664,10 @@ export async function upsertInboxState(opts: {
       dismissedAt,
       doneAt,
       readAt,
+      opts.lastReadAt ?? null,
       now,
       now,
+      opts.lastReadAt !== undefined ? 1 : 0,
     ],
   );
   if (!row) throw new Error("Failed to upsert inbox state");
@@ -12881,6 +12949,8 @@ interface ListRecentSessionsOpts {
   contextKeyPrefix?: string;
   /** When true, return slim `SessionListItemSummary` rows (default: full). */
   slim?: boolean;
+  /** Restrict to sessions this viewer may open (session sharing). */
+  viewer?: SessionViewer;
 }
 
 export async function listRecentSessions(
@@ -12899,7 +12969,7 @@ export async function listRecentSessions(
   const requestedByUserId = opts?.requestedByUserId?.trim() || undefined;
 
   const conditions: string[] = ["r.parentTaskId IS NULL"];
-  const params: (string | number)[] = [];
+  const params: (string | number | null)[] = [];
 
   if (sources.length > 0) {
     conditions.push(`r.source IN (${sources.map(() => "?").join(", ")})`);
@@ -12918,6 +12988,11 @@ export async function listRecentSessions(
     conditions.push(`r.contextKey LIKE ? ESCAPE '\\'`);
     params.push(literalPrefixPattern(opts.contextKeyPrefix));
   }
+  if (opts?.viewer) {
+    const viewer = sessionViewerCondition(opts.viewer);
+    conditions.push(viewer.sql);
+    params.push(...viewer.params);
+  }
   params.push(limit, offset);
 
   const rootRows = await getDbClient().query<
@@ -12989,35 +13064,43 @@ export async function listRecentSessions(
  * a plain count, no recursive chain walk needed.
  */
 export async function countSessions(
-  opts?: Pick<ListRecentSessionsOpts, "source" | "q" | "requestedByUserId" | "contextKeyPrefix">,
+  opts?: Pick<
+    ListRecentSessionsOpts,
+    "source" | "q" | "requestedByUserId" | "contextKeyPrefix" | "viewer"
+  >,
 ): Promise<number> {
   const sources = opts?.source?.filter((s) => s.length > 0) ?? [];
   const q = opts?.q?.trim();
   const requestedByUserId = opts?.requestedByUserId?.trim() || undefined;
 
-  const conditions: string[] = ["parentTaskId IS NULL"];
-  const params: string[] = [];
+  const conditions: string[] = ["r.parentTaskId IS NULL"];
+  const params: (string | null)[] = [];
 
   if (sources.length > 0) {
-    conditions.push(`source IN (${sources.map(() => "?").join(", ")})`);
+    conditions.push(`r.source IN (${sources.map(() => "?").join(", ")})`);
     params.push(...sources);
   }
   if (q && q.length > 0) {
-    conditions.push("(lower(task) LIKE ? OR lower(COALESCE(title, '')) LIKE ?)");
+    conditions.push("(lower(r.task) LIKE ? OR lower(COALESCE(r.title, '')) LIKE ?)");
     const like = `%${q.toLowerCase()}%`;
     params.push(like, like);
   }
   if (requestedByUserId) {
-    conditions.push("requestedByUserId = ?");
+    conditions.push("r.requestedByUserId = ?");
     params.push(requestedByUserId);
   }
   if (opts?.contextKeyPrefix) {
-    conditions.push(`contextKey LIKE ? ESCAPE '\\'`);
+    conditions.push(`r.contextKey LIKE ? ESCAPE '\\'`);
     params.push(literalPrefixPattern(opts.contextKeyPrefix));
   }
+  if (opts?.viewer) {
+    const viewer = sessionViewerCondition(opts.viewer);
+    conditions.push(viewer.sql);
+    params.push(...viewer.params);
+  }
 
   const row = await getDbClient().get<{ count: number }>(
-    `SELECT COUNT(*) AS count FROM agent_tasks WHERE ${conditions.join(" AND ")}`,
+    `SELECT COUNT(*) AS count FROM agent_tasks r WHERE ${conditions.join(" AND ")}`,
     params,
   );
   return row?.count ?? 0;

package/src/be/events.ts

@@ -1,6 +1,7 @@
 import type { EventCategory, EventName, EventSource, EventStatus, SwarmEvent } from "../types";
 import { type ScrubbedText, scrubObject, scrubSecrets } from "../utils/secret-scrubber";
 import { getDbClient } from "./db";
+import { readableSessionCondition } from "./db/tasks/read";
 import type { DbExecutor } from "./db-client";
 import { breaksJsonValidity } from "./scrub-json";
 import { recordSkillInvocation } from "./skill-invocations";
@@ -262,10 +263,20 @@ export async function getEventsFiltered(filters: {
    * the agent's event history.
    */
   latestPerDataField?: { events: EventName[]; dataFields: string[] };
+  /** Only events outside sessions this user may not read; `userId: null` is a guest. */
+  readableBy?: { userId: string | null };
 }): Promise<SwarmEvent[]> {
   const conditions: string[] = [];
   const params: (string | number)[] = [];
 
+  if (filters.readableBy) {
+    const readable = readableSessionCondition(filters.readableBy.userId, "events.taskId", {
+      nullable: true,
+    });
+    conditions.push(readable.sql);
+    params.push(...readable.params);
+  }
+
   if (filters.category) {
     conditions.push("category = ?");
     params.push(filters.category);

package/src/be/migrations/227_inbox_item_state_last_read_at.sql

@@ -0,0 +1 @@
+ALTER TABLE inbox_item_state ADD COLUMN lastReadAt TEXT;

package/src/be/migrations/230_session_shares.sql

@@ -0,0 +1,23 @@
+-- Session sharing. A session is a root task (parentTaskId IS NULL) plus its
+-- descendants. A root with no active row stays private to its owner
+-- (agent_tasks.requestedByUserId); a root with no owner stays open to all.
+--
+-- Rows are never deleted: revoking sets revokedAt/revokedBy, and an access
+-- change revokes the active row and inserts a new one in one transaction, so
+-- every row for a root is its share history. userId NULL means everyone.
+CREATE TABLE session_shares (
+  id TEXT PRIMARY KEY,
+  rootTaskId TEXT NOT NULL REFERENCES agent_tasks(id) ON DELETE CASCADE,
+  userId TEXT REFERENCES users(id),
+  access TEXT NOT NULL CHECK (access IN ('read', 'write')),
+  createdAt TEXT NOT NULL,
+  revokedAt TEXT,
+  revokedBy TEXT REFERENCES users(id),
+  created_by TEXT REFERENCES users(id),
+  updated_by TEXT REFERENCES users(id)
+);
+
+-- At most one active row per (root, target); revoked rows pile up beside it.
+CREATE UNIQUE INDEX session_shares_active
+  ON session_shares(rootTaskId, COALESCE(userId, '*')) WHERE revokedAt IS NULL;
+CREATE INDEX session_shares_user ON session_shares(userId) WHERE revokedAt IS NULL;

package/src/be/rbac-roles.ts

@@ -35,6 +35,8 @@ export const BUILTIN_ROLES = [
       "task.action.own",
       "task.fs.mutate",
       "favorite.write.own",
+      "session.share",
+      "session.presence",
     ],
   },
 ] satisfies (BuiltinRoleDefinition & { isBuiltin: true })[];

package/src/be/seed-scripts/catalog/heartbeat-jev-gate.ts

@@ -138,8 +138,7 @@ async function buildState(ctx: any, leadId: string, nowMs: number, timeZone: str
   // db_query_concurrency_cap on a busy swarm.
   const lead = await q("SELECT heartbeatMd FROM agents WHERE id = ?", [leadId]);
   const prev = await q(
-    `SELECT id, substr(output, 1, 400) AS output,
-            substr(task, 1, instr(task, '## Your Standing Orders')) AS status
+    `SELECT id, substr(output, 1, 400) AS output
        FROM agent_tasks
       WHERE agentId = ? AND taskType = 'heartbeat-checklist' AND status = 'completed'
       ORDER BY createdAt DESC LIMIT 1`,
@@ -163,9 +162,28 @@ async function buildState(ctx: any, leadId: string, nowMs: number, timeZone: str
     "SELECT status, COUNT(*) AS n FROM agents WHERE COALESCE(role, '') != 'extension' GROUP BY status",
   );
 
+  // Only the producer's receipt proves which full IDs the checklist actually showed.
+  // Old checklists and invalid receipts conservatively treat all current failures as new.
+  let reportedIds: unknown = [];
+  if (prev[0]?.id) {
+    try {
+      const receipt = await ctx.swarm.kv_getOrNull({
+        namespace: "heartbeat-checklist:reported-failures",
+        key: prev[0].id,
+      });
+      reportedIds = typeof receipt?.value === "string" ? JSON.parse(receipt.value) : receipt?.value;
+    } catch {
+      reportedIds = [];
+    }
+  }
+  const prevIds = new Set(
+    Array.isArray(reportedIds) && reportedIds.every((id) => typeof id === "string") ? reportedIds : [],
+  );
   const fails = parseFailures(failed.map(renderFailureLine).join("\n"));
-  const prevIds = new Set(parseFailures(String(prev[0]?.status ?? "")).map((f) => f.id));
-  const newFails = fails.filter((f) => !prevIds.has(f.id));
+  // Compare full IDs before rendering the replay's eight-character display IDs.
+  const newFails = parseFailures(
+    failed.filter((f) => !prevIds.has(f.id)).map(renderFailureLine).join("\n"),
+  );
 
   const { stamp, zone } = localStamp(nowMs, timeZone);
   const mmdd = new Date(nowMs).toISOString().slice(5, 10);