@penclipai/server 2026.704.0 → 2026.714.0-canary.0

package/dist/services/document-annotations.d.ts

@@ -16,12 +16,17 @@ export declare function documentAnnotationService(db: Db): {
         status?: "open" | "resolved" | "all";
         includeComments?: boolean;
     }) => Promise<DocumentAnnotationThread[]>;
+    listThreadsForCaseDocument: (caseId: string, key: string, options?: {
+        status?: "open" | "resolved" | "all";
+        includeComments?: boolean;
+    }) => Promise<DocumentAnnotationThread[]>;
     getThreadForIssueDocument: (issueId: string, key: string, threadId: string) => Promise<{
         comments: DocumentAnnotationComment[];
         id: string;
         companyId: string;
         issueId: string | null;
         routineId?: string | null;
+        caseId?: string | null;
         documentId: string;
         documentKey: string;
         status: import("@penclipai/shared").DocumentAnnotationThreadStatus;
@@ -53,6 +58,39 @@ export declare function documentAnnotationService(db: Db): {
         companyId: string;
         issueId: string | null;
         routineId?: string | null;
+        caseId?: string | null;
+        documentId: string;
+        documentKey: string;
+        status: import("@penclipai/shared").DocumentAnnotationThreadStatus;
+        anchorState: import("@penclipai/shared").DocumentAnnotationAnchorState;
+        anchorConfidence: import("@penclipai/shared").DocumentAnnotationAnchorConfidence;
+        originalRevisionId: string | null;
+        originalRevisionNumber: number;
+        currentRevisionId: string | null;
+        currentRevisionNumber: number;
+        selectedText: string;
+        prefixText: string;
+        suffixText: string;
+        normalizedStart: number;
+        normalizedEnd: number;
+        markdownStart: number;
+        markdownEnd: number;
+        anchorSelector: import("@penclipai/shared").DocumentAnnotationAnchorSelector;
+        createdByAgentId: string | null;
+        createdByUserId: string | null;
+        resolvedByAgentId: string | null;
+        resolvedByUserId: string | null;
+        resolvedAt: Date | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    getThreadForCaseDocument: (caseId: string, key: string, threadId: string) => Promise<{
+        comments: DocumentAnnotationComment[];
+        id: string;
+        companyId: string;
+        issueId: string | null;
+        routineId?: string | null;
+        caseId?: string | null;
         documentId: string;
         documentKey: string;
         status: import("@penclipai/shared").DocumentAnnotationThreadStatus;
@@ -85,6 +123,7 @@ export declare function documentAnnotationService(db: Db): {
             threadId: string;
             issueId: string | null;
             routineId: string | null;
+            caseId: string | null;
             documentId: string;
             body: string;
             authorType: "user" | "agent" | "system";
@@ -99,6 +138,7 @@ export declare function documentAnnotationService(db: Db): {
         companyId: string;
         issueId: string | null;
         routineId: string | null;
+        caseId: string | null;
         documentId: string;
         documentKey: string;
         status: "resolved" | "open";
@@ -131,6 +171,55 @@ export declare function documentAnnotationService(db: Db): {
             threadId: string;
             issueId: string | null;
             routineId: string | null;
+            caseId: string | null;
+            documentId: string;
+            body: string;
+            authorType: "user" | "agent" | "system";
+            authorAgentId: string | null;
+            authorUserId: string | null;
+            createdByRunId: string | null;
+            issueCommentId: string | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        id: string;
+        companyId: string;
+        issueId: string | null;
+        routineId: string | null;
+        caseId: string | null;
+        documentId: string;
+        documentKey: string;
+        status: "resolved" | "open";
+        anchorState: "active" | "stale" | "orphaned";
+        anchorConfidence: "exact" | "duplicate" | "fuzzy" | "ambiguous" | "missing";
+        originalRevisionId: string | null;
+        originalRevisionNumber: number;
+        currentRevisionId: string | null;
+        currentRevisionNumber: number;
+        selectedText: string;
+        prefixText: string;
+        suffixText: string;
+        normalizedStart: number;
+        normalizedEnd: number;
+        markdownStart: number;
+        markdownEnd: number;
+        anchorSelector: import("@penclipai/shared").DocumentAnnotationAnchorSelector;
+        createdByAgentId: string | null;
+        createdByUserId: string | null;
+        resolvedByAgentId: string | null;
+        resolvedByUserId: string | null;
+        resolvedAt: Date | null;
+        createdAt: Date;
+        updatedAt: Date;
+    }>;
+    createCaseThread: (caseId: string, key: string, input: CreateDocumentAnnotationThread, actor: ActorInput) => Promise<{
+        comments: {
+            id: string;
+            companyId: string;
+            threadId: string;
+            issueId: string | null;
+            routineId: string | null;
+            caseId: string | null;
             documentId: string;
             body: string;
             authorType: "user" | "agent" | "system";
@@ -145,6 +234,7 @@ export declare function documentAnnotationService(db: Db): {
         companyId: string;
         issueId: string | null;
         routineId: string | null;
+        caseId: string | null;
         documentId: string;
         documentKey: string;
         status: "resolved" | "open";
@@ -176,6 +266,7 @@ export declare function documentAnnotationService(db: Db): {
         threadId: string;
         issueId: string | null;
         routineId: string | null;
+        caseId: string | null;
         documentId: string;
         body: string;
         authorType: "user" | "agent" | "system";
@@ -192,6 +283,24 @@ export declare function documentAnnotationService(db: Db): {
         threadId: string;
         issueId: string | null;
         routineId: string | null;
+        caseId: string | null;
+        documentId: string;
+        body: string;
+        authorType: "user" | "agent" | "system";
+        authorAgentId: string | null;
+        authorUserId: string | null;
+        createdByRunId: string | null;
+        issueCommentId: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+    }>;
+    addCaseComment: (caseId: string, key: string, threadId: string, input: CreateDocumentAnnotationComment, actor: ActorInput) => Promise<{
+        id: string;
+        companyId: string;
+        threadId: string;
+        issueId: string | null;
+        routineId: string | null;
+        caseId: string | null;
         documentId: string;
         body: string;
         authorType: "user" | "agent" | "system";
@@ -208,6 +317,7 @@ export declare function documentAnnotationService(db: Db): {
     }>;
     updateThread: (issueId: string, key: string, threadId: string, input: UpdateDocumentAnnotationThread, actor: ActorInput) => Promise<DocumentAnnotationThread>;
     updateRoutineThread: (routineId: string, key: string, threadId: string, input: UpdateDocumentAnnotationThread, actor: ActorInput) => Promise<DocumentAnnotationThread>;
+    updateCaseThread: (caseId: string, key: string, threadId: string, input: UpdateDocumentAnnotationThread, actor: ActorInput) => Promise<DocumentAnnotationThread>;
     remapOpenThreadsForDocument: (input: {
         issueId: string;
         key: string;
@@ -221,6 +331,7 @@ export declare function documentAnnotationService(db: Db): {
             companyId: string;
             issueId: string | null;
             routineId: string | null;
+            caseId: string | null;
             documentId: string;
             documentKey: string;
             status: "resolved" | "open";
@@ -247,9 +358,9 @@ export declare function documentAnnotationService(db: Db): {
             updatedAt: Date;
         };
         snapshot: {
+            companyId: string;
             id: string;
             createdAt: Date;
-            companyId: string;
             documentId: string;
             failureReason: string | null;
             anchorState: "active" | "stale" | "orphaned";
@@ -276,6 +387,7 @@ export declare function documentAnnotationService(db: Db): {
             companyId: string;
             issueId: string | null;
             routineId: string | null;
+            caseId: string | null;
             documentId: string;
             documentKey: string;
             status: "resolved" | "open";
@@ -302,9 +414,65 @@ export declare function documentAnnotationService(db: Db): {
             updatedAt: Date;
         };
         snapshot: {
+            companyId: string;
+            id: string;
+            createdAt: Date;
+            documentId: string;
+            failureReason: string | null;
+            anchorState: "active" | "stale" | "orphaned";
+            anchorConfidence: "exact" | "duplicate" | "fuzzy" | "ambiguous" | "missing";
+            threadId: string;
+            fromRevisionId: string | null;
+            fromRevisionNumber: number | null;
+            toRevisionId: string | null;
+            toRevisionNumber: number;
+            previousAnchor: DocumentAnnotationAnchorSnapshot;
+            nextAnchor: DocumentAnnotationAnchorSnapshot | null;
+        };
+    }[]>;
+    remapOpenThreadsForCaseDocument: (input: {
+        caseId: string;
+        key: string;
+        documentId: string;
+        nextRevisionId: string | null;
+        nextRevisionNumber: number;
+        nextBody: string;
+    }) => Promise<{
+        thread: {
             id: string;
+            companyId: string;
+            issueId: string | null;
+            routineId: string | null;
+            caseId: string | null;
+            documentId: string;
+            documentKey: string;
+            status: "resolved" | "open";
+            anchorState: "active" | "stale" | "orphaned";
+            anchorConfidence: "exact" | "duplicate" | "fuzzy" | "ambiguous" | "missing";
+            originalRevisionId: string | null;
+            originalRevisionNumber: number;
+            currentRevisionId: string | null;
+            currentRevisionNumber: number;
+            selectedText: string;
+            prefixText: string;
+            suffixText: string;
+            normalizedStart: number;
+            normalizedEnd: number;
+            markdownStart: number;
+            markdownEnd: number;
+            anchorSelector: import("@penclipai/shared").DocumentAnnotationAnchorSelector;
+            createdByAgentId: string | null;
+            createdByUserId: string | null;
+            resolvedByAgentId: string | null;
+            resolvedByUserId: string | null;
+            resolvedAt: Date | null;
             createdAt: Date;
+            updatedAt: Date;
+        };
+        snapshot: {
             companyId: string;
+            id: string;
+            createdAt: Date;
             documentId: string;
             failureReason: string | null;
             anchorState: "active" | "stale" | "orphaned";

package/dist/services/document-annotations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"document-annotations.d.ts","sourceRoot":"","sources":["../../src/services/document-annotations.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,eAAe,CAAC;AAUxC,OAAO,EAGL,wBAAwB,EAExB,KAAK,gCAAgC,EACrC,KAAK,yBAAyB,EAC9B,KAAK,wBAAwB,EAC7B,+BAA+B,EAC/B,8BAA8B,EAC9B,8BAA8B,EAC/B,MAAM,mBAAmB,CAAC;AAG3B,KAAK,UAAU,GAAG;IAChB,SAAS,EAAE,OAAO,GAAG,MAAM,CAAC;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB,CAAC;AAkFF,wBAAgB,yBAAyB,CAAC,EAAE,EAAE,EAAE;2CAiHjC,MAAM,OACV,MAAM,YACF;QAAE,MAAM,CAAC,EAAE,MAAM,GAAG,UAAU,GAAG,KAAK,CAAC;QAAC,eAAe,CAAC,EAAE,OAAO,CAAA;KAAE;+CA+BjE,MAAM,OACZ,MAAM,YACF;QAAE,MAAM,CAAC,EAAE,MAAM,GAAG,UAAU,GAAG,KAAK,CAAC;QAAC,eAAe,CAAC,EAAE,OAAO,CAAA;KAAE;yCA+BnC,MAAM,OAAO,MAAM,YAAY,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6CAOjC,MAAM,OAAO,MAAM,YAAY,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAUzE,MAAM,OACV,MAAM,SACJ,8BAA8B,SAC9B,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAoFN,MAAM,OACZ,MAAM,SACJ,8BAA8B,SAC9B,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAqFR,MAAM,OACV,MAAM,YACD,MAAM,SACT,+BAA+B,SAC/B,UAAU;;;;;;;;;;;;;;;;mCA+BN,MAAM,OACZ,MAAM,YACD,MAAM,SACT,+BAA+B,SAC/B,UAAU;;;;;;;;;;;;;;;;8CAiCR,MAAM,kBACC,MAAM,SACf,UAAU,WACT,GAAG;;;;4BA8DF,MAAM,OACV,MAAM,YACD,MAAM,SACT,8BAA8B,SAC9B,UAAU;qCA8BN,MAAM,OACZ,MAAM,YACD,MAAM,SACT,8BAA8B,SAC9B,UAAU;yCA+BwB;QACzC,OAAO,EAAE,MAAM,CAAC;QAChB,GAAG,EAAE,MAAM,CAAC;QACZ,UAAU,EAAE,MAAM,CAAC;QACnB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;QAC9B,kBAAkB,EAAE,MAAM,CAAC;QAC3B,QAAQ,EAAE,MAAM,CAAC;KAClB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gDAoEiD;QAChD,SAAS,EAAE,MAAM,CAAC;QAClB,GAAG,EAAE,MAAM,CAAC;QACZ,UAAU,EAAE,MAAM,CAAC;QACnB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;QAC9B,kBAAkB,EAAE,MAAM,CAAC;QAC3B,QAAQ,EAAE,MAAM,CAAC;KAClB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsEJ"}
+{"version":3,"file":"document-annotations.d.ts","sourceRoot":"","sources":["../../src/services/document-annotations.ts"],"names":[],"mappings":"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"}

package/dist/services/document-annotations.js

@@ -1,5 +1,5 @@
 import { and, asc, desc, eq, inArray, isNull, sql } from "drizzle-orm";
-import { documentAnnotationAnchorSnapshots, documentAnnotationComments, documentAnnotationThreads, documents, issueComments, issueDocuments, routineDocuments, } from "@penclipai/db";
+import { documentAnnotationAnchorSnapshots, documentAnnotationComments, documentAnnotationThreads, documents, caseDocuments, issueComments, issueDocuments, routineDocuments, } from "@penclipai/db";
 import { anchorSnapshotToSelector, remapDocumentAnchor, selectorToAnchorSnapshot, verifyDocumentAnchorSelector, } from "@penclipai/shared";
 import { conflict, notFound, unprocessable } from "../errors.js";
 const threadSelect = {
@@ -7,6 +7,7 @@ const threadSelect = {
     companyId: documentAnnotationThreads.companyId,
     issueId: documentAnnotationThreads.issueId,
     routineId: documentAnnotationThreads.routineId,
+    caseId: documentAnnotationThreads.caseId,
     documentId: documentAnnotationThreads.documentId,
     documentKey: documentAnnotationThreads.documentKey,
     status: documentAnnotationThreads.status,
@@ -38,6 +39,7 @@ const commentSelect = {
     threadId: documentAnnotationComments.threadId,
     issueId: documentAnnotationComments.issueId,
     routineId: documentAnnotationComments.routineId,
+    caseId: documentAnnotationComments.caseId,
     documentId: documentAnnotationComments.documentId,
     body: documentAnnotationComments.body,
     authorType: documentAnnotationComments.authorType,
@@ -92,6 +94,22 @@ export function documentAnnotationService(db) {
             .where(and(eq(routineDocuments.routineId, routineId), eq(routineDocuments.key, key), eq(routineDocuments.companyId, documents.companyId)))
             .then((rows) => rows[0] ?? null);
     }
+    async function getCaseDocument(caseId, key, dbOrTx = db) {
+        return dbOrTx
+            .select({
+            caseId: caseDocuments.caseId,
+            companyId: documents.companyId,
+            documentId: documents.id,
+            documentKey: caseDocuments.key,
+            latestBody: documents.latestBody,
+            latestRevisionId: documents.latestRevisionId,
+            latestRevisionNumber: documents.latestRevisionNumber,
+        })
+            .from(caseDocuments)
+            .innerJoin(documents, eq(caseDocuments.documentId, documents.id))
+            .where(and(eq(caseDocuments.caseId, caseId), eq(caseDocuments.key, key), eq(caseDocuments.companyId, documents.companyId)))
+            .then((rows) => rows[0] ?? null);
+    }
     async function getThreadForIssue(issueId, documentKey, threadId, dbOrTx = db) {
         return dbOrTx
             .select(threadSelect)
@@ -106,6 +124,13 @@ export function documentAnnotationService(db) {
             .where(and(eq(documentAnnotationThreads.id, threadId), eq(documentAnnotationThreads.companyId, companyId), eq(documentAnnotationThreads.routineId, routineId), eq(documentAnnotationThreads.documentId, documentId), eq(documentAnnotationThreads.documentKey, documentKey)))
             .then((rows) => rows[0] ?? null);
     }
+    async function getThreadForCase(caseId, documentKey, threadId, companyId, documentId, dbOrTx = db) {
+        return dbOrTx
+            .select(threadSelect)
+            .from(documentAnnotationThreads)
+            .where(and(eq(documentAnnotationThreads.id, threadId), eq(documentAnnotationThreads.companyId, companyId), eq(documentAnnotationThreads.caseId, caseId), eq(documentAnnotationThreads.documentId, documentId), eq(documentAnnotationThreads.documentKey, documentKey)))
+            .then((rows) => rows[0] ?? null);
+    }
     async function commentsForThreads(threadIds, dbOrTx = db) {
         if (threadIds.length === 0)
             return [];
@@ -194,6 +219,37 @@ export function documentAnnotationService(db) {
                 comments: commentsByThread.get(thread.id) ?? [],
             }));
         },
+        listThreadsForCaseDocument: async (caseId, key, options = {}) => {
+            const doc = await getCaseDocument(caseId, key);
+            if (!doc)
+                throw notFound("Document not found");
+            const conditions = [
+                eq(documentAnnotationThreads.companyId, doc.companyId),
+                eq(documentAnnotationThreads.caseId, caseId),
+                eq(documentAnnotationThreads.documentId, doc.documentId),
+            ];
+            if (options.status && options.status !== "all") {
+                conditions.push(eq(documentAnnotationThreads.status, options.status));
+            }
+            const threads = await db
+                .select(threadSelect)
+                .from(documentAnnotationThreads)
+                .where(and(...conditions))
+                .orderBy(desc(documentAnnotationThreads.updatedAt), desc(documentAnnotationThreads.id));
+            if (!options.includeComments)
+                return threads;
+            const comments = await commentsForThreads(threads.map((thread) => thread.id));
+            const commentsByThread = new Map();
+            for (const comment of comments) {
+                const existing = commentsByThread.get(comment.threadId) ?? [];
+                existing.push(comment);
+                commentsByThread.set(comment.threadId, existing);
+            }
+            return threads.map((thread) => ({
+                ...thread,
+                comments: commentsByThread.get(thread.id) ?? [],
+            }));
+        },
         getThreadForIssueDocument: async (issueId, key, threadId) => {
             const thread = await getThreadForIssue(issueId, key, threadId);
             if (!thread)
@@ -211,6 +267,16 @@ export function documentAnnotationService(db) {
             const comments = await commentsForThreads([thread.id]);
             return { ...thread, comments };
         },
+        getThreadForCaseDocument: async (caseId, key, threadId) => {
+            const doc = await getCaseDocument(caseId, key);
+            if (!doc)
+                return null;
+            const thread = await getThreadForCase(caseId, key, threadId, doc.companyId, doc.documentId);
+            if (!thread)
+                return null;
+            const comments = await commentsForThreads([thread.id]);
+            return { ...thread, comments };
+        },
         createThread: async (issueId, key, input, actor) => db.transaction(async (tx) => {
             await tx.execute(sql `
         select ${documents.id}
@@ -364,6 +430,85 @@ export function documentAnnotationService(db) {
                 .returning(commentSelect);
             return { ...thread, comments: [comment] };
         }),
+        createCaseThread: async (caseId, key, input, actor) => db.transaction(async (tx) => {
+            await tx.execute(sql `
+        select ${documents.id}
+        from ${caseDocuments}
+        inner join ${documents} on ${caseDocuments.documentId} = ${documents.id}
+        where ${and(eq(caseDocuments.caseId, caseId), eq(caseDocuments.key, key))}
+        for update of ${documents}
+      `);
+            const doc = await getCaseDocument(caseId, key, tx);
+            if (!doc)
+                throw notFound("Document not found");
+            if (input.baseRevisionId !== doc.latestRevisionId
+                || input.baseRevisionNumber !== doc.latestRevisionNumber) {
+                throw conflict("Annotation anchor requires the current document revision", {
+                    currentRevisionId: doc.latestRevisionId,
+                    currentRevisionNumber: doc.latestRevisionNumber,
+                });
+            }
+            const verification = verifyDocumentAnchorSelector({
+                markdown: doc.latestBody,
+                selector: input.selector,
+            });
+            if (!verification.ok || !verification.anchor) {
+                throw unprocessable("Annotation anchor does not match the current document revision", {
+                    reason: verification.reason,
+                });
+            }
+            const now = new Date();
+            const [thread] = await tx
+                .insert(documentAnnotationThreads)
+                .values({
+                companyId: doc.companyId,
+                issueId: null,
+                routineId: null,
+                caseId,
+                documentId: doc.documentId,
+                documentKey: doc.documentKey,
+                status: "open",
+                anchorState: "active",
+                anchorConfidence: "exact",
+                originalRevisionId: doc.latestRevisionId,
+                originalRevisionNumber: doc.latestRevisionNumber,
+                currentRevisionId: doc.latestRevisionId,
+                currentRevisionNumber: doc.latestRevisionNumber,
+                selectedText: verification.anchor.selectedText,
+                prefixText: verification.anchor.prefixText,
+                suffixText: verification.anchor.suffixText,
+                normalizedStart: verification.anchor.normalizedStart,
+                normalizedEnd: verification.anchor.normalizedEnd,
+                markdownStart: verification.anchor.markdownStart,
+                markdownEnd: verification.anchor.markdownEnd,
+                anchorSelector: input.selector,
+                createdByAgentId: actor.agentId ?? null,
+                createdByUserId: actor.userId ?? null,
+                createdAt: now,
+                updatedAt: now,
+            })
+                .returning(threadSelect);
+            const [comment] = await tx
+                .insert(documentAnnotationComments)
+                .values({
+                companyId: doc.companyId,
+                threadId: thread.id,
+                issueId: null,
+                routineId: null,
+                caseId,
+                documentId: doc.documentId,
+                body: input.body,
+                authorType: actor.actorType,
+                authorAgentId: actor.agentId ?? null,
+                authorUserId: actor.userId ?? null,
+                createdByRunId: actor.runId ?? null,
+                issueCommentId: null,
+                createdAt: now,
+                updatedAt: now,
+            })
+                .returning(commentSelect);
+            return { ...thread, comments: [comment] };
+        }),
         addComment: async (issueId, key, threadId, input, actor) => db.transaction(async (tx) => {
             const thread = await getThreadForIssue(issueId, key, threadId, tx);
             if (!thread)
@@ -425,6 +570,39 @@ export function documentAnnotationService(db) {
                 .where(eq(documentAnnotationThreads.id, thread.id));
             return comment;
         }),
+        addCaseComment: async (caseId, key, threadId, input, actor) => db.transaction(async (tx) => {
+            const doc = await getCaseDocument(caseId, key, tx);
+            if (!doc)
+                throw notFound("Document not found");
+            const thread = await getThreadForCase(caseId, key, threadId, doc.companyId, doc.documentId, tx);
+            if (!thread)
+                throw notFound("Annotation thread not found");
+            const now = new Date();
+            const [comment] = await tx
+                .insert(documentAnnotationComments)
+                .values({
+                companyId: thread.companyId,
+                threadId: thread.id,
+                issueId: null,
+                routineId: null,
+                caseId: thread.caseId,
+                documentId: thread.documentId,
+                body: input.body,
+                authorType: actor.actorType,
+                authorAgentId: actor.agentId ?? null,
+                authorUserId: actor.userId ?? null,
+                createdByRunId: actor.runId ?? null,
+                issueCommentId: null,
+                createdAt: now,
+                updatedAt: now,
+            })
+                .returning(commentSelect);
+            await tx
+                .update(documentAnnotationThreads)
+                .set({ updatedAt: now })
+                .where(eq(documentAnnotationThreads.id, thread.id));
+            return comment;
+        }),
         cleanupForIssueCommentDeletion: async (issueId, issueCommentId, actor, dbOrTx = db) => {
             const runCleanup = async (tx) => {
                 const linkedComments = await tx
@@ -530,6 +708,37 @@ export function documentAnnotationService(db) {
                 .returning(threadSelect);
             return updated;
         }),
+        updateCaseThread: async (caseId, key, threadId, input, actor) => db.transaction(async (tx) => {
+            const doc = await getCaseDocument(caseId, key, tx);
+            if (!doc)
+                throw notFound("Document not found");
+            const thread = await getThreadForCase(caseId, key, threadId, doc.companyId, doc.documentId, tx);
+            if (!thread)
+                throw notFound("Annotation thread not found");
+            if (!input.status || input.status === thread.status)
+                return thread;
+            const now = new Date();
+            const [updated] = await tx
+                .update(documentAnnotationThreads)
+                .set(input.status === "resolved"
+                ? {
+                    status: "resolved",
+                    resolvedByAgentId: actor.agentId ?? null,
+                    resolvedByUserId: actor.userId ?? null,
+                    resolvedAt: now,
+                    updatedAt: now,
+                }
+                : {
+                    status: "open",
+                    resolvedByAgentId: null,
+                    resolvedByUserId: null,
+                    resolvedAt: null,
+                    updatedAt: now,
+                })
+                .where(eq(documentAnnotationThreads.id, thread.id))
+                .returning(threadSelect);
+            return updated;
+        }),
         remapOpenThreadsForDocument: async (input) => db.transaction(async (tx) => {
             const threads = await tx
                 .select(threadSelect)
@@ -654,6 +863,68 @@ export function documentAnnotationService(db) {
             }
             return changed;
         }),
+        remapOpenThreadsForCaseDocument: async (input) => db.transaction(async (tx) => {
+            const threads = await tx
+                .select(threadSelect)
+                .from(documentAnnotationThreads)
+                .where(and(eq(documentAnnotationThreads.caseId, input.caseId), eq(documentAnnotationThreads.documentId, input.documentId), eq(documentAnnotationThreads.status, "open")));
+            const changed = [];
+            const now = new Date();
+            for (const thread of threads) {
+                if (thread.currentRevisionId === input.nextRevisionId)
+                    continue;
+                const previousAnchor = snapshotFromThread(thread);
+                const remap = remapDocumentAnchor({
+                    previousAnchor,
+                    nextMarkdown: input.nextBody,
+                });
+                const nextAnchor = remap.anchor;
+                const nextSelector = nextAnchor ? anchorSnapshotToSelector(nextAnchor) : thread.anchorSelector;
+                const [updated] = await tx
+                    .update(documentAnnotationThreads)
+                    .set({
+                    currentRevisionId: input.nextRevisionId,
+                    currentRevisionNumber: input.nextRevisionNumber,
+                    anchorState: remap.anchorState,
+                    anchorConfidence: remap.confidence,
+                    ...(nextAnchor
+                        ? {
+                            selectedText: nextAnchor.selectedText,
+                            prefixText: nextAnchor.prefixText,
+                            suffixText: nextAnchor.suffixText,
+                            normalizedStart: nextAnchor.normalizedStart,
+                            normalizedEnd: nextAnchor.normalizedEnd,
+                            markdownStart: nextAnchor.markdownStart,
+                            markdownEnd: nextAnchor.markdownEnd,
+                        }
+                        : {}),
+                    anchorSelector: nextSelector,
+                    updatedAt: now,
+                })
+                    .where(eq(documentAnnotationThreads.id, thread.id))
+                    .returning(threadSelect);
+                const [snapshot] = await tx
+                    .insert(documentAnnotationAnchorSnapshots)
+                    .values({
+                    companyId: thread.companyId,
+                    threadId: thread.id,
+                    documentId: thread.documentId,
+                    fromRevisionId: thread.currentRevisionId,
+                    fromRevisionNumber: thread.currentRevisionNumber,
+                    toRevisionId: input.nextRevisionId,
+                    toRevisionNumber: input.nextRevisionNumber,
+                    previousAnchor,
+                    nextAnchor,
+                    anchorState: remap.anchorState,
+                    anchorConfidence: remap.confidence,
+                    failureReason: remap.anchor ? null : remap.reason,
+                    createdAt: now,
+                })
+                    .returning();
+                changed.push({ thread: updated, snapshot });
+            }
+            return changed;
+        }),
         selectorToAnchorSnapshot,
     };
 }