patchrelay 0.35.12 → 0.35.14

package/dist/cli/watch/render-rich-text.js

@@ -0,0 +1,225 @@
+const richTextCache = new Map();
+export function lineToPlainText(line) {
+    return line.segments.map((segment) => segment.text).join("");
+}
+export function renderTextLines(text, options) {
+    const width = Math.max(8, options.width);
+    const sourceLines = text.length === 0 ? [""] : text.split("\n");
+    const lines = [];
+    for (let index = 0; index < sourceLines.length; index += 1) {
+        const sourceLine = sourceLines[index] ?? "";
+        const wrapped = wrapSegments(tokenizeSegments([{ text: sourceLine, ...(options.style ?? {}) }]), width, index === 0 ? options.firstPrefix : options.continuationPrefix ?? options.firstPrefix, options.continuationPrefix ?? options.firstPrefix, `${options.key}-${index}`);
+        lines.push(...wrapped);
+    }
+    return lines.length > 0 ? lines : [{ key: `${options.key}-0`, segments: [] }];
+}
+export function renderRichTextLines(text, options) {
+    const width = Math.max(8, options.width);
+    const cacheKey = [
+        options.key,
+        width,
+        segmentsKey(options.firstPrefix),
+        segmentsKey(options.continuationPrefix),
+        styleKey(options.style),
+        options.codeColor ?? "",
+        text,
+    ].join("\u0000");
+    const cached = richTextCache.get(cacheKey);
+    if (cached) {
+        return cached;
+    }
+    const lines = [];
+    const inputLines = text.replace(/\r\n/g, "\n").split("\n");
+    let paragraph = [];
+    let inCodeBlock = false;
+    let codeLines = [];
+    let blockIndex = 0;
+    const flushParagraph = () => {
+        if (paragraph.length === 0)
+            return;
+        const paragraphText = paragraph.join(" ").replace(/\s+/g, " ").trim();
+        if (paragraphText.length > 0) {
+            lines.push(...wrapSegments(tokenizeSegments(parseInlineMarkdown(paragraphText, options.style)), width, lines.length === 0 ? options.firstPrefix : options.continuationPrefix ?? options.firstPrefix, options.continuationPrefix ?? options.firstPrefix, `${options.key}-p-${blockIndex}`));
+            blockIndex += 1;
+        }
+        paragraph = [];
+    };
+    const flushCodeBlock = () => {
+        if (codeLines.length === 0)
+            return;
+        for (const codeLine of codeLines) {
+            lines.push(...renderTextLines(codeLine, {
+                key: `${options.key}-code-${blockIndex}`,
+                width,
+                firstPrefix: lines.length === 0 ? options.firstPrefix : options.continuationPrefix ?? options.firstPrefix,
+                continuationPrefix: options.continuationPrefix ?? options.firstPrefix,
+                style: { color: options.codeColor ?? "green" },
+            }));
+            blockIndex += 1;
+        }
+        codeLines = [];
+    };
+    const pushBlankLine = () => {
+        lines.push({ key: `${options.key}-blank-${blockIndex}`, segments: [] });
+        blockIndex += 1;
+    };
+    for (const rawLine of inputLines) {
+        const line = rawLine ?? "";
+        const trimmed = line.trim();
+        if (trimmed.startsWith("```")) {
+            flushParagraph();
+            if (inCodeBlock) {
+                flushCodeBlock();
+                inCodeBlock = false;
+            }
+            else {
+                inCodeBlock = true;
+            }
+            continue;
+        }
+        if (inCodeBlock) {
+            codeLines.push(line);
+            continue;
+        }
+        if (trimmed.length === 0) {
+            flushParagraph();
+            if (lines.length > 0) {
+                pushBlankLine();
+            }
+            continue;
+        }
+        const bulletMatch = line.match(/^\s*[-*]\s+(.*)$/);
+        if (bulletMatch?.[1]) {
+            flushParagraph();
+            lines.push(...wrapSegments(tokenizeSegments(parseInlineMarkdown(bulletMatch[1], options.style)), width, appendSegments(options.firstPrefix, [{ text: "• ", ...(options.style ?? {}) }]), appendSegments(options.continuationPrefix ?? options.firstPrefix, [{ text: "  ", ...(options.style ?? {}) }]), `${options.key}-b-${blockIndex}`));
+            blockIndex += 1;
+            continue;
+        }
+        paragraph.push(trimmed);
+    }
+    flushParagraph();
+    flushCodeBlock();
+    const result = lines.length > 0 ? lines : [{ key: `${options.key}-0`, segments: [] }];
+    richTextCache.set(cacheKey, result);
+    return result;
+}
+function parseInlineMarkdown(text, style) {
+    const pattern = /\[([^\]]+)\]\(([^)]+)\)|`([^`]+)`|\*\*([^*]+)\*\*/g;
+    const segments = [];
+    let lastIndex = 0;
+    for (const match of text.matchAll(pattern)) {
+        const index = match.index ?? 0;
+        if (index > lastIndex) {
+            segments.push({ text: text.slice(lastIndex, index), ...(style ?? {}) });
+        }
+        if (match[1] && match[2]) {
+            segments.push({ text: match[1], color: "cyan", bold: true });
+        }
+        else if (match[3]) {
+            segments.push({ text: match[3], color: "yellow", bold: true });
+        }
+        else if (match[4]) {
+            segments.push({ text: match[4], ...(style ?? {}), bold: true });
+        }
+        lastIndex = index + match[0].length;
+    }
+    if (lastIndex < text.length) {
+        segments.push({ text: text.slice(lastIndex), ...(style ?? {}) });
+    }
+    return segments.length > 0 ? segments : [{ text, ...(style ?? {}) }];
+}
+function wrapSegments(tokens, width, firstPrefix, continuationPrefix, keyPrefix) {
+    const initialPrefix = cloneSegments(firstPrefix);
+    const nextPrefix = cloneSegments(continuationPrefix);
+    const lines = [];
+    let currentSegments = initialPrefix;
+    let currentWidth = segmentsWidth(initialPrefix);
+    let lineHasContent = false;
+    let lineIndex = 0;
+    const pushLine = () => {
+        lines.push({
+            key: `${keyPrefix}-${lineIndex}`,
+            segments: trimTrailingSpaces(currentSegments),
+        });
+        lineIndex += 1;
+        currentSegments = cloneSegments(nextPrefix);
+        currentWidth = segmentsWidth(currentSegments);
+        lineHasContent = false;
+    };
+    for (const token of tokens) {
+        let remaining = token.text.replace(/\t/g, "  ");
+        while (remaining.length > 0) {
+            const whitespace = remaining.match(/^\s+/)?.[0];
+            if (whitespace) {
+                const spaceText = lineHasContent ? whitespace : "";
+                remaining = remaining.slice(whitespace.length);
+                if (spaceText.length === 0) {
+                    continue;
+                }
+                if (currentWidth + spaceText.length > width) {
+                    pushLine();
+                    continue;
+                }
+                currentSegments.push({ ...token, text: spaceText });
+                currentWidth += spaceText.length;
+                continue;
+            }
+            const word = remaining.match(/^\S+/)?.[0] ?? remaining;
+            remaining = remaining.slice(word.length);
+            let rest = word;
+            while (rest.length > 0) {
+                const available = Math.max(1, width - currentWidth);
+                if (lineHasContent && rest.length > available) {
+                    pushLine();
+                    continue;
+                }
+                const sliceLength = Math.min(rest.length, available);
+                const chunk = rest.slice(0, sliceLength);
+                currentSegments.push({ ...token, text: chunk });
+                currentWidth += chunk.length;
+                lineHasContent = true;
+                rest = rest.slice(sliceLength);
+                if (rest.length > 0) {
+                    pushLine();
+                }
+            }
+        }
+    }
+    if (lines.length === 0 || currentSegments.length > 0 || lineHasContent) {
+        lines.push({
+            key: `${keyPrefix}-${lineIndex}`,
+            segments: trimTrailingSpaces(currentSegments),
+        });
+    }
+    return lines;
+}
+function tokenizeSegments(segments) {
+    return segments.flatMap((segment) => {
+        const parts = segment.text.length === 0 ? [""] : segment.text.match(/\s+|\S+/g) ?? [segment.text];
+        return parts.map((part) => ({ ...segment, text: part }));
+    });
+}
+function cloneSegments(segments) {
+    return (segments ?? []).map((segment) => ({ ...segment }));
+}
+function segmentsWidth(segments) {
+    return (segments ?? []).reduce((sum, segment) => sum + segment.text.length, 0);
+}
+function trimTrailingSpaces(segments) {
+    const trimmed = cloneSegments(segments);
+    while (trimmed.length > 0 && trimmed[trimmed.length - 1]?.text.trim().length === 0) {
+        trimmed.pop();
+    }
+    return trimmed;
+}
+function appendSegments(base, extra) {
+    return [...cloneSegments(base), ...cloneSegments(extra)];
+}
+function segmentsKey(segments) {
+    return (segments ?? []).map((segment) => `${segment.text}|${segment.color ?? ""}|${segment.dimColor ? "d" : ""}|${segment.bold ? "b" : ""}`).join(";");
+}
+function styleKey(style) {
+    if (!style)
+        return "";
+    return `${style.color ?? ""}|${style.dimColor ? "d" : ""}|${style.bold ? "b" : ""}`;
+}

package/dist/cli/watch/watch-state.js

@@ -8,6 +8,10 @@ function capArray(arr, max) {
 }
 const DETAIL_INITIAL = {
     detailTab: "timeline",
+    detailScrollOffset: 0,
+    detailViewportRows: 0,
+    detailContentRows: 0,
+    detailUnreadBelow: 0,
     timeline: [],
     rawRuns: [],
     rawFeedEvents: [],
@@ -79,6 +83,60 @@ function nextFilter(filter) {
         case "all": return "non-done";
     }
 }
+function clampIndex(index, length) {
+    return Math.max(0, Math.min(index, Math.max(0, length - 1)));
+}
+function selectedIssueKeyForFilter(state) {
+    const filtered = filterIssues(state.issues, state.filter);
+    return filtered[state.selectedIndex]?.issueKey ?? null;
+}
+function selectedIndexForSnapshot(state, nextIssues) {
+    const nextFiltered = filterIssues(nextIssues, state.filter);
+    if (nextFiltered.length === 0)
+        return 0;
+    const selectedIssueKey = selectedIssueKeyForFilter(state);
+    if (selectedIssueKey) {
+        const selectedIndex = nextFiltered.findIndex((issue) => issue.issueKey === selectedIssueKey);
+        if (selectedIndex >= 0)
+            return selectedIndex;
+    }
+    return clampIndex(state.selectedIndex, nextFiltered.length);
+}
+const DETAIL_BOTTOM_THRESHOLD = 2;
+function maxDetailScrollOffset(contentRows, viewportRows) {
+    return Math.max(0, contentRows - viewportRows);
+}
+function isDetailNearBottom(scrollOffset, contentRows, viewportRows) {
+    const maxOffset = maxDetailScrollOffset(contentRows, viewportRows);
+    return scrollOffset >= Math.max(0, maxOffset - DETAIL_BOTTOM_THRESHOLD);
+}
+function detailStateForPosition(state, scrollOffset, follow) {
+    const maxOffset = maxDetailScrollOffset(state.detailContentRows, state.detailViewportRows);
+    const nextOffset = clampIndex(scrollOffset, maxOffset + 1);
+    const nextFollow = follow || isDetailNearBottom(nextOffset, state.detailContentRows, state.detailViewportRows);
+    return {
+        detailScrollOffset: nextFollow ? maxOffset : nextOffset,
+        detailUnreadBelow: nextFollow ? 0 : Math.max(0, maxOffset - nextOffset),
+        follow: nextFollow,
+    };
+}
+function detailStateAfterLayout(state, viewportRows, contentRows) {
+    const nextState = {
+        ...state,
+        detailViewportRows: Math.max(0, viewportRows),
+        detailContentRows: Math.max(0, contentRows),
+    };
+    const maxOffset = maxDetailScrollOffset(nextState.detailContentRows, nextState.detailViewportRows);
+    const shouldFollow = state.follow || isDetailNearBottom(state.detailScrollOffset, state.detailContentRows, state.detailViewportRows);
+    const nextOffset = shouldFollow ? maxOffset : Math.min(state.detailScrollOffset, maxOffset);
+    return {
+        detailViewportRows: nextState.detailViewportRows,
+        detailContentRows: nextState.detailContentRows,
+        detailScrollOffset: nextOffset,
+        detailUnreadBelow: shouldFollow ? 0 : Math.max(0, maxOffset - nextOffset),
+        follow: shouldFollow,
+    };
+}
 // ─── Reducer ──────────────────────────────────────────────────────
 export function watchReducer(state, action) {
     switch (action.type) {
@@ -93,17 +151,17 @@ export function watchReducer(state, action) {
                 ...state,
                 lastServerMessageAt: action.receivedAt,
                 issues: action.issues,
-                selectedIndex: Math.min(state.selectedIndex, Math.max(0, action.issues.length - 1)),
+                selectedIndex: selectedIndexForSnapshot(state, action.issues),
             };
         case "feed-event":
             return applyFeedEvent(state, action.event, action.receivedAt);
         case "select":
             return {
                 ...state,
-                selectedIndex: Math.max(0, Math.min(action.index, state.issues.length - 1)),
+                selectedIndex: clampIndex(action.index, filterIssues(state.issues, state.filter).length),
             };
         case "enter-detail":
-            return { ...state, view: "detail", activeDetailKey: action.issueKey, ...DETAIL_INITIAL };
+            return { ...state, view: "detail", activeDetailKey: action.issueKey, follow: true, ...DETAIL_INITIAL };
         case "exit-detail":
             return { ...state, view: "list", activeDetailKey: null, ...DETAIL_INITIAL };
         case "detail-navigate": {
@@ -117,8 +175,46 @@ export function watchReducer(state, action) {
             const nextIssue = list[nextIdx];
             if (!nextIssue?.issueKey || nextIssue.issueKey === state.activeDetailKey)
                 return state;
-            return { ...state, activeDetailKey: nextIssue.issueKey, selectedIndex: nextIdx, ...DETAIL_INITIAL };
+            return { ...state, activeDetailKey: nextIssue.issueKey, selectedIndex: nextIdx, follow: true, ...DETAIL_INITIAL };
+        }
+        case "detail-scroll":
+            return {
+                ...state,
+                ...detailStateForPosition(state, state.detailScrollOffset + action.delta, false),
+            };
+        case "detail-page": {
+            const pageSize = Math.max(1, state.detailViewportRows - 2);
+            const delta = action.direction === "down" ? pageSize : -pageSize;
+            return {
+                ...state,
+                ...detailStateForPosition(state, state.detailScrollOffset + delta, false),
+            };
         }
+        case "detail-jump":
+            return action.target === "end"
+                ? {
+                    ...state,
+                    ...detailStateForPosition(state, maxDetailScrollOffset(state.detailContentRows, state.detailViewportRows), true),
+                }
+                : {
+                    ...state,
+                    ...detailStateForPosition(state, 0, false),
+                };
+        case "detail-layout-updated":
+            {
+                const nextDetailState = detailStateAfterLayout(state, action.viewportRows, action.contentRows);
+                if (nextDetailState.detailViewportRows === state.detailViewportRows
+                    && nextDetailState.detailContentRows === state.detailContentRows
+                    && nextDetailState.detailScrollOffset === state.detailScrollOffset
+                    && nextDetailState.detailUnreadBelow === state.detailUnreadBelow
+                    && nextDetailState.follow === state.follow) {
+                    return state;
+                }
+                return {
+                    ...state,
+                    ...nextDetailState,
+                };
+            }
         case "timeline-rehydrate": {
             const timeline = buildTimelineFromRehydration(action.runs, action.feedEvents, action.liveThread, action.activeRunId);
             const activeRun = action.runs.find((r) => r.id === action.activeRunId);
@@ -137,7 +233,16 @@ export function watchReducer(state, action) {
         case "cycle-filter":
             return { ...state, filter: nextFilter(state.filter), selectedIndex: 0 };
         case "toggle-follow":
-            return { ...state, follow: !state.follow };
+            return state.follow
+                ? {
+                    ...state,
+                    follow: false,
+                    detailUnreadBelow: Math.max(0, maxDetailScrollOffset(state.detailContentRows, state.detailViewportRows) - state.detailScrollOffset),
+                }
+                : {
+                    ...state,
+                    ...detailStateForPosition(state, maxDetailScrollOffset(state.detailContentRows, state.detailViewportRows), true),
+                };
         case "enter-feed":
             return { ...state, view: "feed", activeDetailKey: null, ...DETAIL_INITIAL };
         case "exit-feed":
@@ -147,7 +252,7 @@ export function watchReducer(state, action) {
         case "feed-new-event":
             return { ...state, feedEvents: capArray([...state.feedEvents, action.event], MAX_FEED_EVENTS) };
         case "switch-detail-tab":
-            return { ...state, detailTab: action.tab };
+            return { ...state, follow: true, ...DETAIL_INITIAL, detailTab: action.tab };
         default:
             return state;
     }

package/dist/github-webhook-handler.js

@@ -32,8 +32,9 @@ export class GitHubWebhookHandler {
     feed;
     failureContextResolver;
     ciSnapshotResolver;
+    fetchImpl;
     patchRelayAuthorLogins = new Set();
-    constructor(config, db, linearProvider, enqueueIssue, logger, codex, feed, failureContextResolver = createGitHubFailureContextResolver(), ciSnapshotResolver = createGitHubCiSnapshotResolver()) {
+    constructor(config, db, linearProvider, enqueueIssue, logger, codex, feed, failureContextResolver = createGitHubFailureContextResolver(), ciSnapshotResolver = createGitHubCiSnapshotResolver(), fetchImpl = fetch) {
         this.config = config;
         this.db = db;
         this.linearProvider = linearProvider;
@@ -43,6 +44,7 @@ export class GitHubWebhookHandler {
         this.feed = feed;
         this.failureContextResolver = failureContextResolver;
         this.ciSnapshotResolver = ciSnapshotResolver;
+        this.fetchImpl = fetchImpl;
         for (const login of resolvePatchRelayAuthorLoginsFromEnv()) {
             this.patchRelayAuthorLogins.add(login);
         }
@@ -193,6 +195,7 @@ export class GitHubWebhookHandler {
                 lastAttemptedFailureHeadSha: null,
                 lastAttemptedFailureSignature: null,
             });
+            await this.maybeRequestRereviewAfterPush(freshIssue, event, project);
         }
         this.logger.info({ issueKey: issue.issueKey, branchName: event.branchName, triggerEvent: event.triggerEvent, prNumber: event.prNumber }, "GitHub webhook: updated issue PR state");
         this.feed?.publish({
@@ -434,13 +437,26 @@ export class GitHubWebhookHandler {
         }
         if (event.triggerEvent === "review_changes_requested") {
             const hadPendingWake = this.db.hasPendingIssueSessionEvents(issue.projectId, issue.linearIssueId);
+            const reviewComments = await this.fetchReviewCommentsForEvent(event).catch((error) => {
+                this.logger.warn({
+                    issueKey: issue.issueKey,
+                    prNumber: event.prNumber,
+                    reviewId: event.reviewId,
+                    error: error instanceof Error ? error.message : String(error),
+                }, "Failed to fetch inline review comments for requested-changes event");
+                return undefined;
+            });
             this.db.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,
                 eventType: "review_changes_requested",
                 eventJson: JSON.stringify({
                     reviewBody: event.reviewBody,
+                    reviewCommitId: event.reviewCommitId,
+                    reviewId: event.reviewId,
+                    reviewUrl: buildGitHubReviewUrl(event.repoFullName, event.prNumber, event.reviewId),
                     reviewerName: event.reviewerName,
+                    ...(reviewComments && reviewComments.length > 0 ? { reviewComments } : {}),
                 }),
                 dedupeKey: [
                     "review_changes_requested",
@@ -461,7 +477,9 @@ export class GitHubWebhookHandler {
                 stage: "changes_requested",
                 status: "review_fix_queued",
                 summary: `${queuedRunType ?? "review_fix"} queued after requested changes`,
-                detail: event.reviewBody?.slice(0, 200) ?? event.reviewerName,
+                detail: reviewComments && reviewComments.length > 0
+                    ? `${reviewComments.length} inline review comment${reviewComments.length === 1 ? "" : "s"} captured`
+                    : event.reviewBody?.slice(0, 200) ?? event.reviewerName,
             });
         }
     }
@@ -805,6 +823,64 @@ export class GitHubWebhookHandler {
             this.logger.warn({ issueKey: issue.issueKey, error: msg }, "Failed to sync Linear session from GitHub webhook");
         }
     }
+    async fetchReviewCommentsForEvent(event) {
+        if (event.triggerEvent !== "review_changes_requested") {
+            return undefined;
+        }
+        if (!event.repoFullName || event.prNumber === undefined || event.reviewId === undefined) {
+            return undefined;
+        }
+        const token = process.env.GITHUB_TOKEN ?? process.env.GH_TOKEN;
+        if (!token) {
+            this.logger.debug({ prNumber: event.prNumber, reviewId: event.reviewId }, "Skipping inline review comment fetch because no GitHub API token is available");
+            return undefined;
+        }
+        const [owner, repo] = event.repoFullName.split("/", 2);
+        if (!owner || !repo) {
+            return undefined;
+        }
+        const response = await this.fetchImpl(`https://api.github.com/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/pulls/${event.prNumber}/reviews/${event.reviewId}/comments?per_page=100`, {
+            headers: {
+                Authorization: `Bearer ${token}`,
+                Accept: "application/vnd.github+json",
+                "User-Agent": "patchrelay",
+                "X-GitHub-Api-Version": "2022-11-28",
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`GitHub review comment fetch failed (${response.status})`);
+        }
+        const payload = await response.json();
+        if (!Array.isArray(payload)) {
+            return undefined;
+        }
+        const comments = [];
+        for (const entry of payload) {
+            if (!entry || typeof entry !== "object")
+                continue;
+            const record = entry;
+            const body = typeof record.body === "string" ? record.body.trim() : "";
+            const id = typeof record.id === "number" ? record.id : undefined;
+            if (!body || id === undefined)
+                continue;
+            comments.push({
+                id,
+                body,
+                ...(typeof record.path === "string" ? { path: record.path } : {}),
+                ...(typeof record.line === "number" ? { line: record.line } : {}),
+                ...(typeof record.side === "string" ? { side: record.side } : {}),
+                ...(typeof record.start_line === "number" ? { startLine: record.start_line } : {}),
+                ...(typeof record.start_side === "string" ? { startSide: record.start_side } : {}),
+                ...(typeof record.commit_id === "string" ? { commitId: record.commit_id } : {}),
+                ...(typeof record.html_url === "string" ? { url: record.html_url } : {}),
+                ...(typeof record.diff_hunk === "string" ? { diffHunk: record.diff_hunk } : {}),
+                ...(typeof record.user?.login === "string"
+                    ? { authorLogin: String(record.user.login) }
+                    : {}),
+            });
+        }
+        return comments;
+    }
     async handlePrComment(payload) {
         if (payload.action !== "created")
             return;
@@ -865,6 +941,98 @@ export class GitHubWebhookHandler {
         });
         this.enqueuePendingSessionWake(issue.projectId, issue.linearIssueId);
     }
+    async maybeRequestRereviewAfterPush(issue, event, project) {
+        if (event.triggerEvent !== "pr_synchronize")
+            return;
+        if (issue.activeRunId !== undefined)
+            return;
+        if (issue.prState !== "open" || issue.prReviewState !== "changes_requested" || issue.prNumber === undefined)
+            return;
+        if (!this.isPatchRelayOwnedPr(issue))
+            return;
+        const reviewerName = this.findLatestRequestedChangesReviewer(issue.projectId, issue.linearIssueId);
+        if (!reviewerName) {
+            this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber }, "Skipping auto re-review request because no prior reviewer was recorded");
+            return;
+        }
+        const repoFullName = project?.github?.repoFullName ?? event.repoFullName;
+        const token = process.env.GITHUB_TOKEN ?? process.env.GH_TOKEN;
+        if (!token) {
+            this.logger.warn({ issueKey: issue.issueKey, prNumber: issue.prNumber }, "Skipping auto re-review request because no GitHub token is available");
+            this.feed?.publish({
+                level: "warn",
+                kind: "github",
+                issueKey: issue.issueKey,
+                projectId: issue.projectId,
+                stage: issue.factoryState,
+                status: "rereview_request_skipped",
+                summary: `Skipped auto re-review request for PR #${issue.prNumber}`,
+                detail: "No GitHub token available for requested_reviewers API call",
+            });
+            return;
+        }
+        const response = await this.fetchImpl(`https://api.github.com/repos/${repoFullName}/pulls/${issue.prNumber}/requested_reviewers`, {
+            method: "POST",
+            headers: {
+                authorization: `Bearer ${token}`,
+                accept: "application/vnd.github+json",
+                "content-type": "application/json",
+                "user-agent": "patchrelay",
+            },
+            body: JSON.stringify({ reviewers: [reviewerName] }),
+        });
+        if (!response.ok) {
+            const detail = await this.readGitHubErrorResponse(response);
+            this.logger.warn({ issueKey: issue.issueKey, prNumber: issue.prNumber, reviewerName, status: response.status, detail }, "Failed to auto request re-review after push");
+            this.feed?.publish({
+                level: "warn",
+                kind: "github",
+                issueKey: issue.issueKey,
+                projectId: issue.projectId,
+                stage: issue.factoryState,
+                status: "rereview_request_failed",
+                summary: `Failed to auto request re-review from ${reviewerName}`,
+                detail,
+            });
+            return;
+        }
+        this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber, reviewerName }, "Auto requested re-review after push");
+        this.feed?.publish({
+            level: "info",
+            kind: "github",
+            issueKey: issue.issueKey,
+            projectId: issue.projectId,
+            stage: issue.factoryState,
+            status: "rereview_requested",
+            summary: `Requested re-review from ${reviewerName} on PR #${issue.prNumber}`,
+        });
+    }
+    findLatestRequestedChangesReviewer(projectId, linearIssueId) {
+        const event = this.db
+            .listIssueSessionEvents(projectId, linearIssueId)
+            .findLast((candidate) => candidate.eventType === "review_changes_requested");
+        if (!event?.eventJson)
+            return undefined;
+        const payload = safeJsonParse(event.eventJson);
+        return typeof payload?.reviewerName === "string" && payload.reviewerName.trim()
+            ? payload.reviewerName.trim()
+            : undefined;
+    }
+    async readGitHubErrorResponse(response) {
+        try {
+            const payload = await response.json();
+            if (typeof payload?.message === "string" && payload.message.trim()) {
+                return payload.message.trim();
+            }
+            if (payload?.errors !== undefined) {
+                return JSON.stringify(payload.errors);
+            }
+        }
+        catch {
+            // Fall through to status text.
+        }
+        return response.statusText || `GitHub API responded with ${response.status}`;
+    }
     peekPendingSessionWakeRunType(projectId, issueId) {
         return this.db.peekIssueSessionWake(projectId, issueId)?.runType;
     }
@@ -901,6 +1069,12 @@ function resolvePatchRelayAuthorLoginsFromEnv() {
         .map((value) => normalizeAuthorLogin(value))
         .filter((value) => Boolean(value));
 }
+function buildGitHubReviewUrl(repoFullName, prNumber, reviewId) {
+    if (!repoFullName || prNumber === undefined || reviewId === undefined) {
+        return undefined;
+    }
+    return `https://github.com/${repoFullName}/pull/${prNumber}#pullrequestreview-${reviewId}`;
+}
 function resolveCheckClass(checkName, project) {
     if (!checkName || !project)
         return "code";

package/dist/github-webhooks.js

@@ -104,6 +104,8 @@ function normalizePullRequestReviewEvent(payload, repoFullName) {
         prAuthorLogin: pr.user?.login ?? undefined,
         reviewState,
         reviewBody: review.body ?? undefined,
+        reviewId: typeof review.id === "number" ? review.id : undefined,
+        reviewCommitId: typeof review.commit_id === "string" ? review.commit_id : undefined,
         reviewerName: review.user?.login ?? undefined,
     };
 }

package/dist/linear-session-sync.js

@@ -325,7 +325,7 @@ function statusHeadline(issue, activeRunType) {
         case "failed":
             return "Needs operator intervention";
         case "escalated":
-            return "Escalated for human help";
+            return "Needs operator intervention";
         case "done":
             return issue.prNumber !== undefined ? `Completed with PR #${issue.prNumber}` : "Completed";
         default: