@cursor/july 0.1.91 → 0.1.93

package/dist/internal/review-comments.js

@@ -14,20 +14,20 @@ export function resolveScmReviewTarget(prUrl) {
     return parsed.kind === "valid" ? parsed.value : undefined;
 }
 /**
- * Reader for a resolved target, mirroring Bugbot's `createPrGitProvider`
+ * Lister for a resolved target, mirroring Bugbot's `createPrGitProvider`
  * dispatch. Returns undefined when the host cannot serve that provider (no
- * GitHub client bound), so callers degrade instead of throwing.
+ * GitHub/Origin client bound), so callers degrade instead of throwing.
  */
-export function createReviewCommentReader(args) {
+export function createReviewCommentLister(args) {
     switch (args.target.provider) {
         case "github":
             return args.github === undefined
                 ? undefined
-                : createHostGithubReviewCommentReader(args.github);
+                : createHostGithubReviewCommentLister(args.github, args.log);
         case "origin":
-            // Public Origin REST lists discussion comments, not diff-anchored
-            // review threads. Stay undefined until a reader can fetch by id.
-            return undefined;
+            return args.origin === undefined
+                ? undefined
+                : createHostOriginReviewCommentLister(args.origin, args.log);
     }
 }
 /**
@@ -39,23 +39,25 @@ export function createReviewThreadResolver(args) {
         case "github":
             return args.github === undefined
                 ? undefined
-                : createHostGithubReviewThreadResolver(args.github);
+                : createHostGithubReviewThreadResolver(args.github, args.log);
         case "origin":
-            return undefined;
+            return args.origin === undefined
+                ? undefined
+                : createHostOriginReviewThreadResolver(args.origin, args.log);
     }
 }
 /**
- * Resolve the review threads that own `commentIds` on `prUrl`.
+ * Resolve `threadIds` on `prUrl`'s PR.
  *
  * No-ops (never throws) when the PR is on an SCM this host cannot write,
- * no client is bound, or `commentIds` is empty. Same degrade-don't-fail
- * posture as {@link createReviewCommentReader}.
+ * no client is bound, or `threadIds` is empty. Same degrade-don't-fail
+ * posture as {@link createReviewCommentLister}.
  */
-export function resolveReviewThreadsForComments(args) {
+export function resolveReviewThreads(args) {
     return __awaiter(this, void 0, void 0, function* () {
         var _a;
-        if (args.commentIds.length === 0) {
-            return skippedResolve("no comments to resolve");
+        if (args.threadIds.length === 0) {
+            return skippedResolve("no threads to resolve");
         }
         const target = resolveScmReviewTarget(args.prUrl);
         if (target === undefined) {
@@ -64,15 +66,15 @@ export function resolveReviewThreadsForComments(args) {
         const resolver = (_a = args.resolver) !== null && _a !== void 0 ? _a : createReviewThreadResolver({
             target,
             github: args.github,
+            origin: args.origin,
+            log: args.log,
         });
         if (resolver === undefined) {
-            return skippedResolve(target.provider === "github"
-                ? "no GitHub client bound to resolve threads"
-                : `no thread resolver for ${target.provider}`);
+            return skippedResolve(`no ${target.provider} client bound to resolve threads`);
         }
-        return resolver.resolveReviewThreadsForComments({
+        return resolver.resolveReviewThreads({
             target,
-            commentIds: args.commentIds,
+            threadIds: args.threadIds,
             signal: args.signal,
         });
     });
@@ -80,140 +82,164 @@ export function resolveReviewThreadsForComments(args) {
 /** Cap on pages pulled per PR; GitHub serves 100 comments per page. */
 const REVIEW_COMMENTS_MAX_PAGES = 5;
 const REVIEW_COMMENTS_PAGE_SIZE = 100;
-/** Cap on review-thread pages when mapping comment ids to GraphQL thread ids. */
+/** Cap on review-thread pages when listing a PR's inline threads. */
 const REVIEW_THREADS_MAX_PAGES = 20;
 const REVIEW_THREADS_PAGE_SIZE = 100;
+/** Cap on Origin comment pages pulled per PR (100 comments per page). */
+const ORIGIN_COMMENTS_MAX_PAGES = 20;
+const ORIGIN_COMMENTS_PAGE_SIZE = 100;
 /**
- * Reads inline review comments through the host GitHub client (Cursor
- * account lease, App installation token, or PAT).
+ * Repo-scope header for GraphQL calls through the Cursor github-proxy.
+ *
+ * The proxy authorizes each call from `x-cursor-github-repos`, which the
+ * channel Octokit derives from REST URLs (`/repos/{owner}/{repo}/…`).
+ * GraphQL posts to `/graphql` — no repo in the URL — so without this
+ * explicit header every GraphQL call is rejected in proxy mode. Harmless
+ * against api.github.com, which ignores unknown headers.
  */
-export function createHostGithubReviewCommentReader(github) {
+function githubGraphqlScopeHeaders(repo) {
+    return { "x-cursor-github-repos": repo.toLowerCase() };
+}
+/**
+ * GitHub review thread → {@link ListedReviewComment} (its opening comment).
+ *
+ * Prefers the `original*` line fields — the position as of the review the
+ * thread belongs to. `line` drifts as the PR gains commits, so a caller
+ * correlating a comment with the review that produced it needs the original
+ * position, the same fields Bugbot carries on `PullRequestCommentOutput`.
+ */
+export function listedCommentFromGithubThread(thread) {
+    var _a, _b, _c, _d, _e;
+    var _f, _g, _h, _j, _k, _l;
+    const opener = (_b = (_a = thread.comments) === null || _a === void 0 ? void 0 : _a.nodes) === null || _b === void 0 ? void 0 : _b[0];
+    if (thread.id === undefined ||
+        thread.id === "" ||
+        opener === null ||
+        opener === undefined ||
+        opener.databaseId === undefined ||
+        opener.databaseId === null ||
+        typeof opener.body !== "string" ||
+        typeof thread.path !== "string" ||
+        thread.path === "") {
+        return undefined;
+    }
+    // Take both lines from the same position set. Mixing them (original end
+    // line with the drifted current start line) would describe a range that
+    // never existed in either revision.
+    const original = (_f = thread.originalLine) !== null && _f !== void 0 ? _f : undefined;
+    const endLine = (_g = original !== null && original !== void 0 ? original : thread.line) !== null && _g !== void 0 ? _g : undefined;
+    if (endLine === undefined) {
+        return undefined;
+    }
+    const startLine = (_h = (original === undefined ? thread.startLine : thread.originalStartLine)) !== null && _h !== void 0 ? _h : endLine;
+    const commitSha = (_j = (_c = opener.originalCommit) === null || _c === void 0 ? void 0 : _c.oid) !== null && _j !== void 0 ? _j : undefined;
+    const authorLogin = (_k = (_d = opener.author) === null || _d === void 0 ? void 0 : _d.login) !== null && _k !== void 0 ? _k : undefined;
+    const authorType = (_l = (_e = opener.author) === null || _e === void 0 ? void 0 : _e.__typename) !== null && _l !== void 0 ? _l : undefined;
+    return Object.assign(Object.assign(Object.assign({ commentId: String(opener.databaseId), numericCommentId: opener.databaseId, threadId: thread.id, resolved: thread.isResolved === true, file: thread.path, startLine,
+        endLine, body: opener.body }, (commitSha === undefined ? {} : { commitSha })), (authorLogin === undefined ? {} : { authorLogin })), (authorType === undefined ? {} : { authorIsBot: authorType === "Bot" }));
+}
+/**
+ * Lists the PR's inline review threads (their opening comments) through the
+ * host GitHub client (Cursor account lease, App installation token, or
+ * PAT). One paged GraphQL query yields, per thread: the resolvable thread
+ * node id, its resolution state, the opener's body/position, and the commit
+ * it was filed against — everything a Bugbot-style re-review needs.
+ */
+export function createHostGithubReviewCommentLister(github, log) {
     return {
-        getReviewComments(_a) {
-            return __awaiter(this, arguments, void 0, function* ({ target, commentIds, signal }) {
+        listReviewComments(_a) {
+            return __awaiter(this, arguments, void 0, function* ({ target, signal }) {
+                var _b, _c;
+                var _d;
                 const [owner, repo] = target.repo.split("/", 2);
                 if (owner === undefined || repo === undefined || repo === "") {
+                    log === null || log === void 0 ? void 0 : log(`github list: unparseable owner/repo "${target.repo}"`);
                     return [];
                 }
                 const octokit = yield github.getOctokit();
                 const comments = [];
-                for (const commentId of commentIds) {
+                let threadCount = 0;
+                let cursor = null;
+                for (let page = 0; page < REVIEW_THREADS_MAX_PAGES; page++) {
                     signal === null || signal === void 0 ? void 0 : signal.throwIfAborted();
-                    try {
-                        const response = yield octokit.rest.pulls.getReviewComment({
-                            owner,
-                            repo,
-                            comment_id: commentId,
-                        });
-                        const normalized = normalizeGithubReviewComment(response.data);
-                        if (normalized !== undefined) {
-                            comments.push(normalized);
+                    const response = (yield octokit.graphql(REVIEW_THREAD_COMMENTS_FOR_PR_QUERY, {
+                        owner,
+                        repo,
+                        number: target.prNumber,
+                        cursor,
+                        headers: githubGraphqlScopeHeaders(target.repo),
+                    }));
+                    const reviewThreads = (_c = (_b = response.repository) === null || _b === void 0 ? void 0 : _b.pullRequest) === null || _c === void 0 ? void 0 : _c.reviewThreads;
+                    for (const thread of (_d = reviewThreads === null || reviewThreads === void 0 ? void 0 : reviewThreads.nodes) !== null && _d !== void 0 ? _d : []) {
+                        if (thread === null || thread === undefined) {
+                            continue;
+                        }
+                        threadCount += 1;
+                        const listed = listedCommentFromGithubThread(thread);
+                        if (listed !== undefined) {
+                            comments.push(listed);
                         }
                     }
-                    catch (_b) {
-                        // Deleted or otherwise unreadable: that finding simply has no
-                        // prior text to judge, which is the same as it not being there.
+                    const pageInfo = reviewThreads === null || reviewThreads === void 0 ? void 0 : reviewThreads.pageInfo;
+                    if ((pageInfo === null || pageInfo === void 0 ? void 0 : pageInfo.hasNextPage) !== true || !pageInfo.endCursor) {
+                        break;
                     }
+                    cursor = pageInfo.endCursor;
                 }
+                log === null || log === void 0 ? void 0 : log(`github list: ${target.repo}#${target.prNumber} has ${threadCount} review thread(s), ${comments.length} with a normalizable opening comment`);
                 return comments;
             });
         },
     };
 }
 /**
- * Resolves inline review threads through the host GitHub client (Cursor
- * account lease, App installation token, or PAT). GitHub GraphQL has no
- * comment→thread field, so this pages the PR's review threads and matches
- * each REST comment id by `databaseId` — the same approach as Bugbot's
- * `resolveReviewThreadForComment`.
+ * Resolves inline review threads by GraphQL thread node id through the host
+ * GitHub client (Cursor account lease, App installation token, or PAT) —
+ * the id the lister already returned, so no comment→thread mapping pass is
+ * needed. Same mutation as Bugbot's `resolveReviewThreadForComment`.
  */
-export function createHostGithubReviewThreadResolver(github) {
+export function createHostGithubReviewThreadResolver(github, log) {
     return {
-        resolveReviewThreadsForComments(_a) {
-            return __awaiter(this, arguments, void 0, function* ({ target, commentIds, signal }) {
-                var _b, _c, _d, _e, _f;
-                var _g, _h;
-                const uniqueIds = [...new Set(commentIds.filter((id) => id > 0))];
+        resolveReviewThreads(_a) {
+            return __awaiter(this, arguments, void 0, function* ({ target, threadIds, signal }) {
+                var _b, _c;
+                const uniqueIds = [...new Set(threadIds.filter((id) => id !== ""))];
                 if (uniqueIds.length === 0) {
-                    return skippedResolve("no comments to resolve");
-                }
-                const [owner, repo] = target.repo.split("/", 2);
-                if (owner === undefined || repo === undefined || repo === "") {
-                    return skippedResolve("unparseable owner/repo from PR URL");
+                    return skippedResolve("no threads to resolve");
                 }
+                let resolved = 0;
+                let failed = 0;
                 try {
                     const octokit = yield github.getOctokit();
-                    const wanted = new Set(uniqueIds);
-                    const matched = new Map();
-                    let cursor = null;
-                    for (let page = 0; page < REVIEW_THREADS_MAX_PAGES; page++) {
-                        signal === null || signal === void 0 ? void 0 : signal.throwIfAborted();
-                        const response = (yield octokit.graphql(REVIEW_THREADS_FOR_PR_QUERY, {
-                            owner,
-                            repo,
-                            number: target.prNumber,
-                            cursor,
-                        }));
-                        const reviewThreads = (_c = (_b = response.repository) === null || _b === void 0 ? void 0 : _b.pullRequest) === null || _c === void 0 ? void 0 : _c.reviewThreads;
-                        for (const thread of (_g = reviewThreads === null || reviewThreads === void 0 ? void 0 : reviewThreads.nodes) !== null && _g !== void 0 ? _g : []) {
-                            if ((thread === null || thread === void 0 ? void 0 : thread.id) === undefined || thread.id === "") {
-                                continue;
-                            }
-                            for (const comment of (_h = (_d = thread.comments) === null || _d === void 0 ? void 0 : _d.nodes) !== null && _h !== void 0 ? _h : []) {
-                                const databaseId = comment === null || comment === void 0 ? void 0 : comment.databaseId;
-                                if (databaseId !== undefined &&
-                                    databaseId !== null &&
-                                    wanted.has(databaseId) &&
-                                    !matched.has(databaseId)) {
-                                    matched.set(databaseId, {
-                                        threadId: thread.id,
-                                        isResolved: thread.isResolved === true,
-                                    });
-                                }
-                            }
-                        }
-                        if (matched.size === wanted.size) {
-                            break;
-                        }
-                        const pageInfo = reviewThreads === null || reviewThreads === void 0 ? void 0 : reviewThreads.pageInfo;
-                        if ((pageInfo === null || pageInfo === void 0 ? void 0 : pageInfo.hasNextPage) !== true || !pageInfo.endCursor) {
-                            break;
-                        }
-                        cursor = pageInfo.endCursor;
-                    }
-                    const toResolve = [
-                        ...new Map([...matched.values()]
-                            .filter((thread) => !thread.isResolved)
-                            .map((thread) => [thread.threadId, thread.threadId])).values(),
-                    ];
-                    let resolved = 0;
-                    let failed = 0;
-                    for (const threadId of toResolve) {
+                    for (const threadId of uniqueIds) {
                         signal === null || signal === void 0 ? void 0 : signal.throwIfAborted();
                         try {
-                            const mutation = (yield octokit.graphql(RESOLVE_REVIEW_THREAD_MUTATION, { threadId }));
-                            if (((_f = (_e = mutation.resolveReviewThread) === null || _e === void 0 ? void 0 : _e.thread) === null || _f === void 0 ? void 0 : _f.isResolved) === true) {
+                            const mutation = (yield octokit.graphql(RESOLVE_REVIEW_THREAD_MUTATION, {
+                                threadId,
+                                headers: githubGraphqlScopeHeaders(target.repo),
+                            }));
+                            if (((_c = (_b = mutation.resolveReviewThread) === null || _b === void 0 ? void 0 : _b.thread) === null || _c === void 0 ? void 0 : _c.isResolved) === true) {
                                 resolved += 1;
+                                log === null || log === void 0 ? void 0 : log(`github resolve: thread ${threadId} resolved`);
                             }
                             else {
                                 failed += 1;
+                                log === null || log === void 0 ? void 0 : log(`github resolve: thread ${threadId} mutation did not mark the thread resolved`);
                             }
                         }
-                        catch (_j) {
+                        catch (error) {
+                            if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                                throw error;
+                            }
                             failed += 1;
+                            log === null || log === void 0 ? void 0 : log(`github resolve: thread ${threadId} failed: ${error instanceof Error ? error.message : String(error)}`);
                         }
                     }
-                    const alreadyResolved = new Set([...matched.values()]
-                        .filter((thread) => thread.isResolved)
-                        .map((thread) => thread.threadId)).size;
-                    const notFound = wanted.size - matched.size;
                     return {
                         requested: uniqueIds.length,
                         resolved,
-                        alreadyResolved,
-                        notFound,
                         failed,
-                        detail: `resolved ${resolved} of ${toResolve.length} open thread(s) for ${uniqueIds.length} comment(s) via host GitHub (${alreadyResolved} already resolved, ${notFound} not found, ${failed} failed)`,
+                        detail: `resolved ${resolved} of ${uniqueIds.length} thread(s) on ${target.repo}#${target.prNumber} via host GitHub (${failed} failed)`,
                     };
                 }
                 catch (error) {
@@ -222,10 +248,8 @@ export function createHostGithubReviewThreadResolver(github) {
                     }
                     return {
                         requested: uniqueIds.length,
-                        resolved: 0,
-                        alreadyResolved: 0,
-                        notFound: 0,
-                        failed: uniqueIds.length,
+                        resolved,
+                        failed: uniqueIds.length - resolved,
                         detail: `host GitHub thread resolve failed: ${error instanceof Error ? error.message : String(error)}`,
                     };
                 }
@@ -233,8 +257,8 @@ export function createHostGithubReviewThreadResolver(github) {
         },
     };
 }
-const REVIEW_THREADS_FOR_PR_QUERY = `
-query ReviewThreadsForPr(
+const REVIEW_THREAD_COMMENTS_FOR_PR_QUERY = `
+query ReviewThreadCommentsForPr(
   $owner: String!
   $repo: String!
   $number: Int!
@@ -246,8 +270,18 @@ query ReviewThreadsForPr(
         nodes {
           id
           isResolved
-          comments(first: ${REVIEW_THREADS_PAGE_SIZE}) {
-            nodes { databaseId }
+          path
+          line
+          originalLine
+          startLine
+          originalStartLine
+          comments(first: 1) {
+            nodes {
+              databaseId
+              body
+              author { login __typename }
+              originalCommit { oid }
+            }
           }
         }
         pageInfo { hasNextPage endCursor }
@@ -263,34 +297,183 @@ mutation ResolveReviewThread($threadId: ID!) {
   }
 }
 `;
+const GITHUB_VIEWER_LOGIN_QUERY = `
+query ViewerLogin {
+  viewer { login }
+}
+`;
 /**
- * GitHub review comment → {@link ExistingReviewComment}.
- *
- * Prefers the `original_*` fields — the path/lines/commit as of the review
- * the comment belongs to. `line` drifts as the PR gains commits, so a
- * caller correlating a comment with the review that produced it needs the
- * original position, the same fields Bugbot carries on
- * `PullRequestCommentOutput`.
+ * The login the bound GitHub client itself acts as — the identity its posts
+ * appear under. Works for installation tokens too (GraphQL `viewer` returns
+ * the app's bot, e.g. `cursor[bot]`), so a reader can trust comments whose
+ * author is provably the same identity it posts with, across every
+ * environment's app (prod/staging/cloud-dev/custom) without hardcoding.
+ * `repo` scopes the call through the Cursor github-proxy (the minted token
+ * — and so the viewer — is per-repo there). Best-effort: `undefined` when
+ * the lookup fails.
  */
-export function normalizeGithubReviewComment(comment) {
-    var _a, _b, _c;
-    // Take both lines from the same position set. Mixing them (original end
-    // line with the drifted current start line) would describe a range that
-    // never existed in either revision.
-    const original = (_a = comment.original_line) !== null && _a !== void 0 ? _a : undefined;
-    const endLine = (_b = original !== null && original !== void 0 ? original : comment.line) !== null && _b !== void 0 ? _b : undefined;
-    if (endLine === undefined || endLine === null) {
+export function fetchGithubSelfLogin(github, args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d;
+        try {
+            const octokit = yield github.getOctokit();
+            (_a = args.signal) === null || _a === void 0 ? void 0 : _a.throwIfAborted();
+            const response = (yield octokit.graphql(GITHUB_VIEWER_LOGIN_QUERY, {
+                headers: githubGraphqlScopeHeaders(args.repo),
+            }));
+            const login = (_b = response.viewer) === null || _b === void 0 ? void 0 : _b.login;
+            return typeof login === "string" && login !== "" ? login : undefined;
+        }
+        catch (error) {
+            if ((_c = args.signal) === null || _c === void 0 ? void 0 : _c.aborted) {
+                throw error;
+            }
+            (_d = args.log) === null || _d === void 0 ? void 0 : _d.call(args, `github viewer lookup failed: ${error instanceof Error ? error.message : String(error)}`);
+            return undefined;
+        }
+    });
+}
+/**
+ * Origin public comment → {@link ListedReviewComment}. Only line-anchored
+ * threads qualify (general-discussion and file-level threads carry no
+ * position a review finding can be pinned to).
+ */
+export function listedCommentFromOriginComment(comment) {
+    var _a, _b, _c, _d;
+    var _e;
+    const thread = comment.thread;
+    if (typeof comment.id !== "string" ||
+        comment.id === "" ||
+        typeof comment.body !== "string" ||
+        thread === undefined ||
+        typeof thread.id !== "string" ||
+        thread.id === "" ||
+        typeof thread.path !== "string" ||
+        thread.path === "" ||
+        typeof thread.startLine !== "number" ||
+        thread.startLine <= 0) {
         return undefined;
     }
-    const startLine = (_c = (original === undefined
-        ? comment.start_line
-        : comment.original_start_line)) !== null && _c !== void 0 ? _c : endLine;
+    const startLine = thread.startLine;
+    const endLine = typeof thread.endLine === "number" && thread.endLine >= startLine
+        ? thread.endLine
+        : startLine;
+    const commitSha = (_a = thread.version) === null || _a === void 0 ? void 0 : _a.headSha;
+    const author = comment.author;
+    const authorLogin = (_e = (_b = author === null || author === void 0 ? void 0 : author.app) === null || _b === void 0 ? void 0 : _b.slug) !== null && _e !== void 0 ? _e : (_c = author === null || author === void 0 ? void 0 : author.user) === null || _c === void 0 ? void 0 : _c.email;
+    // App and service-account actors are machine identities; only a `user`
+    // actor is a human PR participant.
+    const authorIsBot = author === undefined
+        ? undefined
+        : author.app !== undefined || author.serviceAccount !== undefined;
+    const authorAppId = (_d = author === null || author === void 0 ? void 0 : author.app) === null || _d === void 0 ? void 0 : _d.id;
+    return Object.assign(Object.assign(Object.assign(Object.assign({ commentId: comment.id, threadId: thread.id, resolved: typeof thread.resolvedAt === "string" && thread.resolvedAt !== "", file: thread.path, startLine,
+        endLine, body: comment.body }, (typeof commitSha === "string" && commitSha !== "" ? { commitSha } : {})), (typeof authorLogin === "string" && authorLogin !== ""
+        ? { authorLogin }
+        : {})), (authorIsBot === undefined ? {} : { authorIsBot })), (typeof authorAppId === "string" && authorAppId !== ""
+        ? { authorAppId }
+        : {}));
+}
+/**
+ * Lists the PR's inline review threads through the Origin public REST API
+ * (`GET …/pulls/{n}/comments`, paged). The flattened comment list is
+ * ordered by creation time, so the first comment seen per thread is the
+ * thread opener; replies are dropped.
+ */
+export function createHostOriginReviewCommentLister(origin, log) {
     return {
-        id: comment.id,
-        file: comment.path,
-        startLine,
-        endLine,
-        body: comment.body,
+        listReviewComments(_a) {
+            return __awaiter(this, arguments, void 0, function* ({ target, signal }) {
+                var _b, _c;
+                const [owner, repo] = target.repo.split("/", 2);
+                if (owner === undefined || repo === undefined || repo === "") {
+                    log === null || log === void 0 ? void 0 : log(`origin list: unparseable owner/repo "${target.repo}"`);
+                    return [];
+                }
+                const basePath = `/v1/origin/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/pulls/${target.prNumber}/comments`;
+                const comments = [];
+                const seenThreads = new Set();
+                let totalComments = 0;
+                let pageToken = "";
+                for (let page = 0; page < ORIGIN_COMMENTS_MAX_PAGES; page++) {
+                    signal === null || signal === void 0 ? void 0 : signal.throwIfAborted();
+                    const query = pageToken === ""
+                        ? `?pageSize=${ORIGIN_COMMENTS_PAGE_SIZE}`
+                        : `?pageSize=${ORIGIN_COMMENTS_PAGE_SIZE}&pageToken=${encodeURIComponent(pageToken)}`;
+                    const response = (yield origin.request({
+                        method: "GET",
+                        path: `${basePath}${query}`,
+                    }));
+                    for (const comment of (_b = response === null || response === void 0 ? void 0 : response.comments) !== null && _b !== void 0 ? _b : []) {
+                        if (comment === null || comment === undefined) {
+                            continue;
+                        }
+                        totalComments += 1;
+                        const listed = listedCommentFromOriginComment(comment);
+                        if (listed === undefined || seenThreads.has(listed.threadId)) {
+                            // Not line-anchored, or a reply on a thread whose opener was
+                            // already taken (the list is oldest-first).
+                            continue;
+                        }
+                        seenThreads.add(listed.threadId);
+                        comments.push(listed);
+                    }
+                    pageToken = (_c = response === null || response === void 0 ? void 0 : response.nextPageToken) !== null && _c !== void 0 ? _c : "";
+                    if (pageToken === "") {
+                        break;
+                    }
+                }
+                log === null || log === void 0 ? void 0 : log(`origin list: ${target.repo}#${target.prNumber} has ${totalComments} comment(s), ${comments.length} line-anchored thread opener(s)`);
+                return comments;
+            });
+        },
+    };
+}
+/**
+ * Resolves Origin comment threads through the public REST API
+ * (`PATCH …/pulls/threads/{thread_id}` with `resolved: true`).
+ */
+export function createHostOriginReviewThreadResolver(origin, log) {
+    return {
+        resolveReviewThreads(_a) {
+            return __awaiter(this, arguments, void 0, function* ({ target, threadIds, signal }) {
+                const uniqueIds = [...new Set(threadIds.filter((id) => id !== ""))];
+                if (uniqueIds.length === 0) {
+                    return skippedResolve("no threads to resolve");
+                }
+                const [owner, repo] = target.repo.split("/", 2);
+                if (owner === undefined || repo === undefined || repo === "") {
+                    return skippedResolve("unparseable owner/repo from PR URL");
+                }
+                let resolved = 0;
+                let failed = 0;
+                for (const threadId of uniqueIds) {
+                    signal === null || signal === void 0 ? void 0 : signal.throwIfAborted();
+                    try {
+                        yield origin.request({
+                            method: "PATCH",
+                            path: `/v1/origin/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/pulls/threads/${encodeURIComponent(threadId)}`,
+                            body: { resolved: true },
+                        });
+                        resolved += 1;
+                        log === null || log === void 0 ? void 0 : log(`origin resolve: thread ${threadId} resolved`);
+                    }
+                    catch (error) {
+                        if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                            throw error;
+                        }
+                        failed += 1;
+                        log === null || log === void 0 ? void 0 : log(`origin resolve: thread ${threadId} failed: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                }
+                return {
+                    requested: uniqueIds.length,
+                    resolved,
+                    failed,
+                    detail: `resolved ${resolved} of ${uniqueIds.length} thread(s) on ${target.repo}#${target.prNumber} via host Origin (${failed} failed)`,
+                };
+            });
+        },
     };
 }
 /**
@@ -367,9 +550,12 @@ export function createReviewCommentPublisher(args) {
 /**
  * Posts a COMMENT-verdict Origin review through the public REST API.
  *
- * Public Origin REST has no diff-anchored review comments (those are an
- * internal CreateCommentThread RPC). Inline comments in the request are
- * folded into the review body so findings still land on the PR.
+ * Inline comments post as diff-anchored threads via the review's
+ * `comments` field (`ReviewCommentInput` with an `InlineCommentAnchor`).
+ * Origin rejects the whole request with INVALID_ARGUMENT when any anchor
+ * is off the reviewed version's diff — the caller's body-only retry (the
+ * same fallback GitHub's 422 takes) then folds the findings into the
+ * review body.
  */
 export function createHostOriginReviewPublisher(origin) {
     return {
@@ -597,15 +783,19 @@ function postReviewViaHostOrigin(origin, args) {
                 path: `/v1/origin/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/pulls/${target.prNumber}/reviews`,
                 body: {
                     verdict: "comment",
-                    body: originReviewBody(args),
+                    body: args.message,
+                    comments: args.comments.map(toOriginReviewCommentInput),
                 },
             });
+            const inlineCommentCount = args.comments.length;
             return {
                 posted: true,
                 publisher: "host_origin",
-                mode: "review_body_only",
-                inlineCommentCount: 0,
-                detail: `posted Origin review on ${target.repo}#${target.prNumber}`,
+                mode: inlineCommentCount > 0
+                    ? "review_with_inline_comments"
+                    : "review_body_only",
+                inlineCommentCount,
+                detail: `posted Origin review on ${target.repo}#${target.prNumber} with ${inlineCommentCount} inline comment(s)`,
             };
         }
         catch (error) {
@@ -616,30 +806,22 @@ function postReviewViaHostOrigin(origin, args) {
         }
     });
 }
-/**
- * Origin's public CreatePullRequestReview has a body, not inline comments.
- * Fold attempted anchors into the summary so findings are not dropped.
- */
-function originReviewBody(args) {
-    if (args.comments.length === 0) {
-        return args.message;
-    }
-    const sections = args.comments.map((comment) => {
-        const location = comment.start_line !== undefined &&
-            comment.start_line > 0 &&
-            comment.start_line !== comment.line
-            ? `${comment.file}:${comment.start_line}-${comment.line}`
-            : `${comment.file}:${comment.line}`;
-        return `### \`${location}\`\n\n${comment.body}`;
-    });
-    return [args.message, ...sections].join("\n\n");
+/** Provider-neutral inline comment → Origin `ReviewCommentInput`. */
+function toOriginReviewCommentInput(comment) {
+    const startLine = comment.start_line !== undefined &&
+        comment.start_line > 0 &&
+        comment.start_line < comment.line
+        ? comment.start_line
+        : comment.line;
+    return {
+        body: comment.body,
+        inline: Object.assign({ path: comment.file, side: "right", startLine }, (startLine === comment.line ? {} : { endLine: comment.line })),
+    };
 }
 function skippedResolve(detail) {
     return {
         requested: 0,
         resolved: 0,
-        alreadyResolved: 0,
-        notFound: 0,
         failed: 0,
         detail,
     };