Make deleted-comment cleanup atomic

Co-Authored-By: Paperclip <noreply@paperclip.ing>

server/src/__tests__/document-annotations-service.test.ts

@@ -270,4 +270,48 @@ describeEmbeddedPostgres("documentAnnotationService", () => {
 
     await expect(db.select().from(documentAnnotationComments)).resolves.toHaveLength(0);
   });
+
+  it("does not report already-resolved empty threads as newly resolved during linked comment cleanup", async () => {
+    const { companyId, issueId, document } = await createIssueWithDocument();
+    const [issueComment] = await db
+      .insert(issueComments)
+      .values({
+        companyId,
+        issueId,
+        authorType: "user",
+        authorUserId: "board-user",
+        body: "Delete this linked comment from a resolved thread",
+      })
+      .returning();
+
+    const thread = await annotations.createThread(
+      issueId,
+      "plan",
+      {
+        baseRevisionId: document.latestRevisionId!,
+        baseRevisionNumber: document.latestRevisionNumber,
+        selector: {
+          quote: { exact: "selected text", prefix: "Alpha ", suffix: " omega" },
+          position: { normalizedStart: 6, normalizedEnd: 19, markdownStart: 6, markdownEnd: 19 },
+        },
+        body: "Linked annotation body",
+        issueCommentId: issueComment.id,
+      },
+      { actorType: "user", actorId: "board-user", userId: "board-user" },
+    );
+
+    await db
+      .update(documentAnnotationThreads)
+      .set({ status: "resolved", resolvedByUserId: "board-user", resolvedAt: new Date("2026-06-05T03:05:00.000Z") })
+      .where(eq(documentAnnotationThreads.id, thread.id));
+
+    const cleanup = await annotations.cleanupForIssueCommentDeletion(
+      issueId,
+      issueComment.id,
+      { actorType: "user", actorId: "board-user", userId: "board-user" },
+    );
+
+    expect(cleanup.deletedCommentIds).toEqual([thread.comments[0]!.id]);
+    expect(cleanup.resolvedThreadIds).toEqual([]);
+  });
 });

server/src/__tests__/issue-comment-cancel-routes.test.ts

@@ -195,7 +195,8 @@ describe.sequential("issue comment cancel routes", () => {
     mockIssueService.assertCheckoutOwner.mockResolvedValue({ adoptedFromRunId: null });
     mockIssueService.getComment.mockResolvedValue(makeComment());
     mockIssueService.removeComment.mockResolvedValue(makeComment());
-    mockIssueService.tombstoneComment.mockResolvedValue(makeComment({
+    mockIssueService.tombstoneComment.mockImplementation(async (_commentId, _actor, options) => {
+      const deleted = makeComment({
         body: "",
         metadata: null,
         deletedAt: new Date("2026-04-11T15:05:00.000Z"),
@@ -203,7 +204,10 @@ describe.sequential("issue comment cancel routes", () => {
         deletedByAgentId: null,
         deletedByUserId: "local-board",
         deletedByRunId: null,
-    }));
+      });
+      await options?.afterTombstone?.(deleted, "tx");
+      return deleted;
+    });
     mockAccessService.canUser.mockResolvedValue(false);
     mockAccessService.hasPermission.mockResolvedValue(false);
     mockFeedbackService.listIssueVotesForUser.mockResolvedValue([]);
@@ -337,13 +341,17 @@ describe.sequential("issue comment cancel routes", () => {
     expect(JSON.stringify(res.body)).not.toContain("Sensitive original comment body");
     expect(JSON.stringify(res.body)).not.toContain("Sensitive metadata copy");
     expect(mockIssueService.removeComment).not.toHaveBeenCalled();
-    expect(mockIssueService.tombstoneComment).toHaveBeenCalledWith("comment-1", {
+    expect(mockIssueService.tombstoneComment).toHaveBeenCalledWith(
+      "comment-1",
+      {
         actorType: "user",
         agentId: null,
         userId: "local-board",
         runId: null,
-    });
+      },
-    expect(mockIssueReferenceService.syncComment).toHaveBeenCalledWith("comment-1");
+      expect.objectContaining({ afterTombstone: expect.any(Function) }),
+    );
+    expect(mockIssueReferenceService.syncComment).toHaveBeenCalledWith("comment-1", "tx");
     expect(mockDocumentAnnotationService.cleanupForIssueCommentDeletion).toHaveBeenCalledWith(
       "11111111-1111-4111-8111-111111111111",
       "comment-1",
@@ -351,8 +359,9 @@ describe.sequential("issue comment cancel routes", () => {
         actorType: "user",
         userId: "local-board",
       }),
+      "tx",
     );
-    expect(mockIssueReferenceService.deleteCommentSource).toHaveBeenCalledWith("annotation-comment-1");
+    expect(mockIssueReferenceService.deleteCommentSource).toHaveBeenCalledWith("annotation-comment-1", "tx");
     const deletedActivity = mockLogActivity.mock.calls.find((call) => call[1]?.action === "issue.comment_deleted")?.[1];
     expect(deletedActivity).toEqual(expect.objectContaining({
       action: "issue.comment_deleted",

server/src/routes/issues.ts

@@ -5674,29 +5674,37 @@ export function issueRoutes(
       return;
     }
 
-    const deleted = await svc.tombstoneComment(commentId, {
+    let annotationCleanup = { deletedCommentIds: [] as string[], resolvedThreadIds: [] as string[] };
+    const deleted = await svc.tombstoneComment(
+      commentId,
+      {
         actorType: actor.actorType,
         agentId: actor.agentId,
         userId: actor.actorType === "user" ? actor.actorId : null,
         runId: actor.runId,
-    });
+      },
-    if (!deleted) {
+      {
-      res.status(404).json({ error: "Comment not found" });
+        afterTombstone: async (deletedComment, tx) => {
-      return;
+          await issueReferencesSvc.syncComment(deletedComment.id, tx);
-    }
+          annotationCleanup = await documentAnnotationsSvc.cleanupForIssueCommentDeletion(issue.id, deletedComment.id, {
-    await issueReferencesSvc.syncComment(deleted.id);
-    const annotationCleanup = await documentAnnotationsSvc.cleanupForIssueCommentDeletion(issue.id, deleted.id, {
             actorType: actor.actorType,
             actorId: actor.actorId,
             agentId: actor.agentId,
             userId: actor.actorType === "user" ? actor.actorId : null,
             runId: actor.runId,
-    });
+          }, tx);
           await Promise.all(
             annotationCleanup.deletedCommentIds.map((annotationCommentId) =>
-        issueReferencesSvc.deleteCommentSource(annotationCommentId)
+              issueReferencesSvc.deleteCommentSource(annotationCommentId, tx)
             ),
           );
+        },
+      },
+    );
+    if (!deleted) {
+      res.status(404).json({ error: "Comment not found" });
+      return;
+    }
 
     await logActivity(db, {
       companyId: issue.companyId,

server/src/services/document-annotations.ts

@@ -330,7 +330,9 @@ export function documentAnnotationService(db: Db) {
       issueId: string,
       issueCommentId: string,
       actor: ActorInput,
-    ) => db.transaction(async (tx) => {
+      dbOrTx: any = db,
+    ) => {
+      const runCleanup = async (tx: any) => {
         const linkedComments: Array<Pick<DocumentAnnotationComment, "id" | "threadId">> = await tx
           .select({
             id: documentAnnotationComments.id,
@@ -365,7 +367,7 @@ export function documentAnnotationService(db: Db) {
         const emptyThreadIds = threadIds.filter((threadId) => (remainingByThreadId.get(threadId) ?? 0) === 0);
 
         if (emptyThreadIds.length > 0) {
-        await tx
+          const resolvedRows: Array<{ id: string }> = await tx
             .update(documentAnnotationThreads)
             .set({
               status: "resolved",
@@ -377,11 +379,17 @@ export function documentAnnotationService(db: Db) {
             .where(and(
               inArray(documentAnnotationThreads.id, emptyThreadIds),
               eq(documentAnnotationThreads.status, "open"),
-          ));
+            ))
+            .returning({ id: documentAnnotationThreads.id });
+
+          return { deletedCommentIds, resolvedThreadIds: resolvedRows.map((row) => row.id) };
         }
 
-      return { deletedCommentIds, resolvedThreadIds: emptyThreadIds };
+        return { deletedCommentIds, resolvedThreadIds: [] };
-    }),
+      };
+
+      return dbOrTx === db ? db.transaction(runCleanup) : runCleanup(dbOrTx);
+    },
 
     updateThread: async (
       issueId: string,

server/src/services/issues.ts

@@ -34,6 +34,7 @@ import {
 } from "@paperclipai/db";
 import type {
   AcceptedPlanDecomposition,
+  IssueComment,
   IssueCommentAuthorType,
   IssueCommentMetadata,
   IssueCommentPresentation,
@@ -5733,6 +5734,9 @@ export function issueService(db: Db) {
         userId?: string | null;
         runId?: string | null;
       },
+      options?: {
+        afterTombstone?: (comment: IssueComment, tx: any) => Promise<void>;
+      },
     ) => {
       const currentUserRedactionOptions = {
         enabled: (await instanceSettings.getGeneral()).censorUsernameInLogs,
@@ -5763,7 +5767,10 @@ export function issueService(db: Db) {
           .set({ updatedAt: now })
           .where(eq(issues.id, comment.issueId));
 
-        return redactIssueComment(comment, currentUserRedactionOptions.enabled);
+        const redacted = redactIssueComment(comment, currentUserRedactionOptions.enabled);
+        await options?.afterTombstone?.(redacted, tx);
+
+        return redacted;
       });
     },