pierre-review 0.1.59 → 0.1.60

package/dist/api/routes/prs.js

@@ -1,9 +1,10 @@
 import { createHash } from 'node:crypto';
+import { config } from '../../config.js';
 import { getAccessToken, getAccountUserId } from '../../auth/account.js';
 import { fetchActionsJobLog } from '../../github/actions-logs.js';
-import { getMentionCandidates, getPrDetail, getPrFilesContext, getPrWriteContext, getReviewerLogins, markAllViewed, markPrViewed, upsertLocalPrComment, upsertLocalReview, } from '../../db/queries.js';
+import { getMentionCandidates, getPrDetail, getPrFilesContext, getPrWriteContext, getReviewerLogins, markAllViewed, markPrMergedLocally, markPrViewed, upsertLocalPrComment, upsertLocalReview, } from '../../db/queries.js';
 import { buildFileAnchors, fallbackAnchor, isFindingAnchored, } from '../../github/diff-anchor.js';
-import { addIssueComment, fetchHeadShaFor, fetchPrFilesWithPatch, postInlineComment, requestReviewers, rerunWorkflowRun, submitPrReview, } from '../../github/mutations.js';
+import { addIssueComment, fetchHeadShaFor, fetchMergeability, fetchPrFilesWithPatch, fetchPrHeadInfo, fetchRepoMergeConfig, mergePullRequest, postInlineComment, requestReviewers, rerunWorkflowRun, submitPrReview, updatePullRequestBranch, } from '../../github/mutations.js';
 import { hydratePrDetail } from '../../sync/hydrate-detail.js';
 import { accountIdOf } from '../plugins/auth.js';
 // GitHub anchors a file in the PR "Files changed" diff by the SHA-256 of its
@@ -92,6 +93,23 @@ const approveSchema = {
         properties: { body: { type: 'string' } },
     },
 };
+const mergeSchema = {
+    ...idParamSchema,
+    body: {
+        type: 'object',
+        required: ['method'],
+        additionalProperties: false,
+        properties: { method: { type: 'string', enum: ['merge', 'squash', 'rebase'] } },
+    },
+};
+const updateBranchSchema = {
+    ...idParamSchema,
+    body: {
+        type: 'object',
+        additionalProperties: false,
+        properties: { strategy: { type: 'string', enum: ['rebase', 'merge'] } },
+    },
+};
 const reviewCommentSchema = {
     ...idParamSchema,
     body: {
@@ -259,6 +277,187 @@ export async function prRoutes(app) {
             };
         }
     });
+    // ---- Merge (CORE / free tier) ----
+    // The merge control's options — the repo's enabled merge methods + GitHub's live mergeability.
+    // Fetched lazily (only when the control opens) so the hot PR-detail path isn't slowed by a
+    // live GitHub call. Ownership-scoped via getPrWriteContext (→ 404).
+    app.get('/api/prs/:id/merge-options', async (req, reply) => {
+        const { id } = req.params;
+        const accountId = accountIdOf(req);
+        const ctx = await getPrWriteContext(id, accountId);
+        if (!ctx) {
+            reply.status(404);
+            return { error: 'NotFound', message: `PR ${id} not found` };
+        }
+        try {
+            const token = await getAccessToken(accountId);
+            const [cfg, m] = await Promise.all([
+                fetchRepoMergeConfig(token, ctx.owner, ctx.name),
+                fetchMergeability(token, ctx.owner, ctx.name, ctx.number),
+            ]);
+            const allowedMethods = ['merge', 'squash', 'rebase'].filter((meth) => meth === 'merge'
+                ? cfg.allowMergeCommit
+                : meth === 'squash'
+                    ? cfg.allowSquashMerge
+                    : cfg.allowRebaseMerge);
+            const conflicts = m.mergeable === false || m.mergeableState === 'dirty';
+            const behind = m.mergeableState === 'behind' || m.behindBy > 0;
+            const result = {
+                allowedMethods: [...allowedMethods],
+                defaultMethod: allowedMethods[0] ?? 'merge',
+                mergeable: m.mergeable,
+                mergeStateStatus: m.mergeableState,
+                conflicts,
+                behind,
+                blocked: m.mergeableState === 'blocked',
+                behindBy: m.behindBy,
+                baseRef: m.baseRef,
+                canUpdateBranch: behind && !conflicts,
+                canRebaseUpdate: !config.isCloud,
+            };
+            return result;
+        }
+        catch (err) {
+            reply.status(502);
+            return { error: 'GitHubError', message: err instanceof Error ? err.message : String(err) };
+        }
+    });
+    // Merge the PR (native GitHub merge; merge/squash/rebase). Re-checks write+ permission
+    // (author allowed — GitHub lets an author merge their own PR) and pre-checks conflicts, then
+    // pins the merge to the current head SHA (409 if it moved). Optimistically stamps merged.
+    app.post('/api/prs/:id/merge', { schema: mergeSchema }, async (req, reply) => {
+        const { id } = req.params;
+        const { method } = req.body;
+        const accountId = accountIdOf(req);
+        const ctx = await getPrWriteContext(id, accountId);
+        if (!ctx) {
+            reply.status(404);
+            return { error: 'NotFound', message: `PR ${id} not found` };
+        }
+        if (!['WRITE', 'MAINTAIN', 'ADMIN'].includes(ctx.viewerPermission ?? '')) {
+            reply.status(403);
+            return { error: 'NotPermitted', message: 'You need write access to merge this PR.' };
+        }
+        try {
+            const token = await getAccessToken(accountId);
+            // Live conflict pre-check — never attempt a merge on a conflicting PR (no free-tier
+            // resolution). GitHub would 405 anyway; a 409 here is clearer.
+            const m = await fetchMergeability(token, ctx.owner, ctx.name, ctx.number);
+            if (m.mergeable === false || m.mergeableState === 'dirty') {
+                reply.status(409);
+                return {
+                    error: 'Conflicts',
+                    conflicts: true,
+                    message: 'This PR conflicts with the base branch — resolve the conflicts on GitHub.',
+                };
+            }
+            const info = await fetchPrHeadInfo(token, ctx.owner, ctx.name, ctx.number);
+            const out = await mergePullRequest(token, ctx.owner, ctx.name, ctx.number, {
+                method,
+                expectedHeadSha: info.headSha,
+            });
+            if (!out.ok) {
+                const status = out.reason === 'method_disallowed' ? 422 : 409;
+                reply.status(status);
+                return {
+                    error: out.reason === 'head_moved'
+                        ? 'HeadMoved'
+                        : out.reason === 'method_disallowed'
+                            ? 'MethodNotAllowed'
+                            : 'NotMergeable',
+                    message: out.message,
+                };
+            }
+            const viewerUserId = await getAccountUserId(accountId);
+            await markPrMergedLocally(id, accountId, viewerUserId);
+            const result = { merged: true, sha: out.sha, state: 'merged' };
+            return result;
+        }
+        catch (err) {
+            reply.status(502);
+            return { error: 'GitHubError', message: err instanceof Error ? err.message : String(err) };
+        }
+    });
+    // Update the PR's branch from the base/trunk before merging. Local: clone-based rebase
+    // (default) or merge, aborting on ANY conflict (no free-tier resolution → 409). Cloud: GitHub's
+    // native update-branch (merge-only, clone-free). Gated on write+ permission.
+    app.post('/api/prs/:id/update-branch', { schema: updateBranchSchema }, async (req, reply) => {
+        const { id } = req.params;
+        const { strategy } = (req.body ?? {});
+        const accountId = accountIdOf(req);
+        const ctx = await getPrWriteContext(id, accountId);
+        if (!ctx) {
+            reply.status(404);
+            return { error: 'NotFound', message: `PR ${id} not found` };
+        }
+        if (!['WRITE', 'MAINTAIN', 'ADMIN'].includes(ctx.viewerPermission ?? '')) {
+            reply.status(403);
+            return { error: 'NotPermitted', message: 'You need write access to update this branch.' };
+        }
+        try {
+            const token = await getAccessToken(accountId);
+            // Never attempt an update on a conflicting PR — conflict resolution is a Pro feature.
+            const m = await fetchMergeability(token, ctx.owner, ctx.name, ctx.number);
+            if (m.mergeable === false || m.mergeableState === 'dirty') {
+                reply.status(409);
+                return {
+                    error: 'Conflicts',
+                    conflicts: true,
+                    message: 'This PR conflicts with the base branch. Resolving conflicts isn’t available on the free tier — resolve them on GitHub.',
+                };
+            }
+            const info = await fetchPrHeadInfo(token, ctx.owner, ctx.name, ctx.number);
+            if (config.isCloud) {
+                // Cloud: native update-branch (merge trunk in). No clone/git on the host.
+                const out = await updatePullRequestBranch(token, ctx.owner, ctx.name, ctx.number, info.headSha);
+                if (!out.ok) {
+                    reply.status(409);
+                    return out.reason === 'head_moved'
+                        ? { error: 'HeadMoved', headMoved: true, message: out.message }
+                        : { error: 'Conflicts', conflicts: true, message: out.message };
+                }
+                const result = { ok: true, headSha: null, strategy: 'merge' };
+                return result;
+            }
+            // Local: clone-based rebase (default) or merge from trunk, autoResolve:false. Dynamic
+            // import so the clone/git machinery is only loaded on this path (never in cloud).
+            const strat = strategy === 'merge' ? 'merge' : 'rebase';
+            const { updatePrBranchFromTrunk } = await import('../../coding/merge.js');
+            const out = await updatePrBranchFromTrunk({
+                accountId,
+                owner: ctx.owner,
+                name: ctx.name,
+                prNumber: ctx.number,
+                headRef: info.headRef,
+                headSha: info.headSha,
+                trunk: info.baseRef,
+                strategy: strat,
+            });
+            const result = { ok: true, headSha: out.headSha, strategy: out.strategy };
+            return result;
+        }
+        catch (err) {
+            const code = err?.code;
+            if (code === 'CONFLICTS_UNRESOLVED') {
+                reply.status(409);
+                return {
+                    error: 'Conflicts',
+                    conflicts: true,
+                    message: 'This PR conflicts with the base branch. Resolving conflicts isn’t available on the free tier — resolve them on GitHub.',
+                };
+            }
+            if (code === 'HEAD_MOVED') {
+                reply.status(409);
+                return { error: 'HeadMoved', headMoved: true, message: err.message };
+            }
+            if (code === 'PUSH_DENIED') {
+                reply.status(403);
+                return { error: 'NotPermitted', message: err.message };
+            }
+            reply.status(502);
+            return { error: 'GitHubError', message: err instanceof Error ? err.message : String(err) };
+        }
+    });
     // Add ONE inline review comment, posted immediately. Validates the requested
     // (path, line, side) lands on an addable diff line; if not, re-anchors to the
     // file's first changed line; if the file has no changes at all, returns a

package/dist/coding/merge.js

@@ -480,6 +480,66 @@ export async function mergeResolveAndPush(args) {
         await teardown(owner, name, repoCloneDir, worktreePath);
     }
 }
+// ---- CORE (free tier): update a PR's OWN branch from its base/trunk ----
+// Rebase (default) or merge the trunk into the PR's head branch and push. This is the local,
+// clone-based path for the free-tier "Update branch from trunk" — reusing runRebase/runMerge
+// with autoResolve:false, so on ANY conflict the op is aborted and CONFLICTS_UNRESOLVED is
+// thrown (never the SDK resolver — conflict resolution is a Pro feature). No stored patch is
+// involved (unlike the AI-Fix paths above): we check the PR head out as-is and reconcile it.
+export async function updatePrBranchFromTrunk(args) {
+    const { accountId, owner, name, prNumber, headRef, headSha, trunk, strategy } = args;
+    const token = await getAccessToken(accountId);
+    const ident = await identFor(accountId);
+    // The head must not have moved out from under us, and a fork head must be pushable.
+    const info = await fetchPrHeadInfo(token, owner, name, prNumber);
+    if (info.headSha !== headSha) {
+        throw codedError('HEAD_MOVED', `the PR head advanced (now ${info.headSha.slice(0, 7)}, expected ${headSha.slice(0, 7)})`);
+    }
+    if (info.isFork && !info.maintainerCanModify) {
+        throw codedError('PUSH_DENIED', 'the PR head is a fork this account cannot push to — update it on GitHub instead');
+    }
+    // The PR head branch lives in the HEAD repo, which for a fork PR is NOT the base (watched)
+    // repo — push there, or a merge would create a stray branch on the base and a rebase's lease
+    // would target the wrong ref. The clone/fetch still uses the base repo below (pull/N/head
+    // resolves there); only the PUSH target is the head repo. full_name is always `owner/name`.
+    const slash = info.headRepoFullName.indexOf('/');
+    const headOwner = slash > 0 ? info.headRepoFullName.slice(0, slash) : owner;
+    const headName = slash > 0 ? info.headRepoFullName.slice(slash + 1) : name;
+    // autoResolve:false → runRebase/runMerge abort on the first conflict and throw
+    // CONFLICTS_UNRESOLVED; the model/resolver fields are never touched (no SDK import).
+    const opts = {
+        autoResolve: false,
+        model: '',
+        abortController: new AbortController(),
+        onProgress: () => { },
+    };
+    let repoCloneDir = null;
+    let worktreePath = null;
+    try {
+        // Check out the PR head branch (prepWorktree checks out at the given sha).
+        ({ repoCloneDir, worktreePath } = await prepWorktree(owner, name, prNumber, headSha, token));
+        const trunkSha = await fetchTrunk(worktreePath, owner, name, token, trunk);
+        if (strategy === 'rebase') {
+            await runRebase(worktreePath, trunkSha, ident, opts); // throws CONFLICTS_UNRESOLVED on conflict
+            const newSha = (await git(['rev-parse', 'HEAD'], worktreePath)).stdout.trim();
+            // Rewriting history requires a force push; the lease pins to the sha we cloned so a
+            // concurrent push aborts it (never blows away someone else's work).
+            await pushForceWithLease(worktreePath, headOwner, headName, token, 'HEAD', headRef, headSha);
+            return { headSha: newSha, strategy };
+        }
+        await runMerge(worktreePath, trunkSha, trunk, headRef, ident, opts); // throws on conflict
+        const newSha = (await git(['rev-parse', 'HEAD'], worktreePath)).stdout.trim();
+        // A merge only adds a commit (the old head is its ancestor) → a plain push. Already
+        // up-to-date (runMerge no-op) leaves HEAD unchanged → nothing to push.
+        if (newSha !== headSha) {
+            await pushRef(worktreePath, headOwner, headName, token, 'HEAD', headRef);
+        }
+        return { headSha: newSha, strategy };
+    }
+    finally {
+        await teardown(owner, name, repoCloneDir, worktreePath);
+    }
+}
 export async function pushResolved(args) {
     const { accountId, owner, name, prNumber, trunk, mbox, target, onProgress } = args;
     const token = await getAccessToken(accountId);

package/dist/db/queries.js

@@ -1134,6 +1134,76 @@ export async function getActivity(accountId, repoIds, userIds = null) {
 // Every My Turn (participated) event is always kept; the plain activity rows are bounded to
 // the most recent, so a busy multi-repo account doesn't render thousands of them.
 const FEED_EVENT_CAP = 250;
+// A submitted review and the same actor's top-level PR comment(s) on the same PR are folded
+// into ONE card when they land within this window of each other (issue comments carry no head
+// SHA, so time is the only proxy for "posted together"). Symmetric around the review's time.
+const REVIEW_COMMENT_MERGE_WINDOW_MS = 5 * 60 * 1000; // 5 minutes
+// Fold each actor's near-in-time top-level PR comment(s) INTO their review on the same PR
+// (appending to the review's `mergedComments`) and remove those comment rows from `items` +
+// `byId`, IN PLACE. A comment with no review within the window keeps its own row; a comment
+// is claimed by its NEAREST review, so two reviews in one window don't both grab it. This is
+// what collapses "submit a review, then drop a summary comment" into a single feed card.
+// Exported for unit tests (pure over the item arrays).
+export function coalesceReviewComments(items, byId) {
+    const reviewsByKey = new Map();
+    const commentsByKey = new Map();
+    const bucketPush = (m, key, it) => {
+        const arr = m.get(key);
+        if (arr)
+            arr.push(it);
+        else
+            m.set(key, [it]);
+    };
+    for (const it of items) {
+        if (it.actorId == null || it.prId == null)
+            continue;
+        const key = `${it.actorId}:${it.prId}`;
+        if (it.kind === 'review_submitted')
+            bucketPush(reviewsByKey, key, it);
+        else if (it.kind === 'pr_comment' && it.commentId != null)
+            bucketPush(commentsByKey, key, it);
+    }
+    if (reviewsByKey.size === 0 || commentsByKey.size === 0)
+        return;
+    const foldedIds = new Set();
+    for (const [key, comments] of commentsByKey) {
+        const reviews = reviewsByKey.get(key);
+        if (reviews == null)
+            continue;
+        for (const comment of comments) {
+            const ct = Date.parse(comment.occurredAt);
+            let best = null;
+            let bestDist = Infinity;
+            for (const rev of reviews) {
+                const dist = Math.abs(Date.parse(rev.occurredAt) - ct);
+                if (dist <= REVIEW_COMMENT_MERGE_WINDOW_MS && dist < bestDist) {
+                    best = rev;
+                    bestDist = dist;
+                }
+            }
+            if (best == null)
+                continue;
+            best.mergedComments.push({
+                commentId: comment.commentId,
+                content: comment.content ?? '',
+                occurredAt: comment.occurredAt,
+            });
+            foldedIds.add(comment.id);
+        }
+    }
+    if (foldedIds.size === 0)
+        return;
+    // Chronological within each review (a review can fold more than one comment).
+    for (const reviews of reviewsByKey.values())
+        for (const rev of reviews)
+            if (rev.mergedComments.length > 1)
+                rev.mergedComments.sort((a, b) => a.occurredAt.localeCompare(b.occurredAt));
+    for (const id of foldedIds)
+        byId.delete(id);
+    const kept = items.filter((it) => !foldedIds.has(it.id));
+    items.length = 0;
+    items.push(...kept);
+}
 // Commit runs that ADDRESSED a review thread — the only commit activity surfaced in the
 // consolidated feed (plain pushes are noise, hidden on the timeline by default too). A
 // "run" is consecutive commits by one author on one PR (a >6h gap splits runs). A run is
@@ -1359,6 +1429,7 @@ async function getCommitThreadItems(accountId, opts) {
             changeSummary: `pushed ${run.commitCount} ${commitWord} · addressed ${affected.length} ${threadWord}`,
             claudeReviewId: null,
             claudeVerdict: null,
+            mergedComments: [],
         });
     }
     return out;
@@ -1437,6 +1508,7 @@ async function getClaudeReviewFeedItems(accountId, repoIds, since) {
             claudeReviewId: r.reviewId,
             // Prefer the user's decision when they've set one, else Claude's read-only verdict.
             claudeVerdict: r.userVerdict ?? r.verdict,
+            mergedComments: [],
         });
     }
     return out;
@@ -2318,6 +2390,7 @@ export async function getConsolidatedFeed(accountId, opts = {}) {
             changeSummary: null,
             claudeReviewId: null,
             claudeVerdict: null,
+            mergedComments: [],
         });
     }
     // Commit-push items (already repo/member/bot-scoped + thread-enriched in the SQL helper).
@@ -2328,6 +2401,13 @@ export async function getConsolidatedFeed(accountId, opts = {}) {
     // flow but always retained (see the caps below) so the "Claude Reviews" pill finds them.
     for (const it of claudeItems)
         push(it);
+    // Consolidate a submitted review + the SAME actor's top-level PR comment(s) on the SAME PR
+    // posted within a short window (issue comments carry no head SHA, so time is the proxy):
+    // fold the comment(s) into the review's `mergedComments` and drop their standalone rows, so
+    // "review, then a summary comment" reads as one card everywhere (including FYI) instead of
+    // two. Runs BEFORE the FYI enrich/cap/paginate so `total`, participation and page bounds
+    // reflect the collapsed set (a comment folded here is never separately flagged or capped).
+    coalesceReviewComments(items, byId);
     // FYI / "My Turn" enrichment (Pro): flag each item `isMyTurn` by the viewer's participation
     // in its PR. Runs BEFORE the cap so uncapped My-Turn rows survive. No-op (feed stays plain)
     // when the plugin isn't loaded — the free tier.
@@ -3830,6 +3910,22 @@ export async function getPrWriteContext(prId, accountId) {
         prUrl: `https://github.com/${row.owner}/${row.name}/pull/${row.number}`,
     };
 }
+// Optimistically stamp a PR as merged after a successful GitHub merge, so the UI reflects it
+// immediately (the ['pr',id] query is staleTime:Infinity + IndexedDB-persisted, so the mutation
+// MUST invalidate it — but stamping first avoids a flash of the stale 'open' state). Account-
+// scoped. The next sync reconciles the authoritative merge metadata.
+export async function markPrMergedLocally(prId, accountId, mergedById) {
+    await db
+        .update(pullRequests)
+        .set({
+        state: 'merged',
+        mergedAt: new Date(),
+        mergedById,
+        mergeStateStatus: 'unknown',
+    })
+        .where(and(eq(pullRequests.id, prId), eq(pullRequests.accountId, accountId)))
+        .execute();
+}
 // Resolve a set of user ids to their GitHub logins for a reviewer request. Bots are
 // dropped (GitHub 422s on bot reviewers); the `users` table is global so no account
 // scope is needed (the caller already gated the PR by ownership + write access).

package/dist/github/client.js

@@ -64,6 +64,30 @@ export async function ghRestGetDiff(token, path) {
     }
     return res.text();
 }
+// REST PUT returning the parsed STATUS + body WITHOUT throwing on a non-2xx, so the caller can
+// map GitHub's meaningful merge / update-branch statuses to structured results (405 not
+// mergeable, 409 head-sha mismatch, 422 method disallowed / can't update). Per-account token.
+export async function ghRestPutStatus(token, path, body) {
+    const res = await fetch(`https://api.github.com${path}`, {
+        method: 'PUT',
+        headers: {
+            authorization: `token ${token}`,
+            accept: 'application/vnd.github+json',
+            'x-github-api-version': '2022-11-28',
+            ...(body !== undefined ? { 'content-type': 'application/json' } : {}),
+        },
+        body: body !== undefined ? JSON.stringify(body) : undefined,
+    });
+    const text = await res.text().catch(() => '');
+    let json = null;
+    try {
+        json = text ? JSON.parse(text) : null;
+    }
+    catch {
+        /* non-JSON body (rare on these endpoints) */
+    }
+    return { status: res.status, ok: res.ok, json, text };
+}
 // REST POST (submitting a PR review — inline line comments require the REST
 // reviews endpoint) for a specific account's token.
 export function ghRestPostFor(token, path, body) {

package/dist/github/mutations.js

@@ -6,7 +6,7 @@
 //
 // GraphQL note: @octokit/graphql RESERVES the variable name `query`. The
 // operation-variable here is named `input` / etc., never `query`.
-import { getGraphqlClientFor, ghRestGetDiff, ghRestGetFor, ghRestPostFor, ghRestPostNoContent, } from './client.js';
+import { getGraphqlClientFor, ghRestGetDiff, ghRestGetFor, ghRestPostFor, ghRestPostNoContent, ghRestPutStatus, } from './client.js';
 const ADD_REPLY_MUTATION = /* GraphQL */ `
   mutation AddThreadReply($input: AddPullRequestReviewThreadReplyInput!) {
     addPullRequestReviewThreadReply(input: $input) {
@@ -228,6 +228,55 @@ export async function fetchMergeability(token, owner, name, number) {
         aheadBy,
     };
 }
+// ---- PR merge + update-from-trunk (CORE / free tier) ----
+// The repo's enabled merge methods + default branch (GET /repos/{o}/{n}). Not synced — a
+// rarely-changing repo setting, fetched live only when the merge control opens. Missing flags
+// default true (GitHub's own default for a new repo).
+export async function fetchRepoMergeConfig(token, owner, name) {
+    const repo = await ghRestGetFor(token, `/repos/${owner}/${name}`);
+    return {
+        allowMergeCommit: repo.allow_merge_commit ?? true,
+        allowSquashMerge: repo.allow_squash_merge ?? true,
+        allowRebaseMerge: repo.allow_rebase_merge ?? true,
+        defaultBranch: repo.default_branch,
+    };
+}
+// Merge the PR via GitHub's native endpoint (PUT .../merge). Pins `sha` to the expected head so
+// GitHub 409s if the branch moved. Cloud-safe, clone-free. The caller pre-checks conflicts.
+export async function mergePullRequest(token, owner, name, number, opts) {
+    const body = { merge_method: opts.method };
+    if (opts.expectedHeadSha)
+        body.sha = opts.expectedHeadSha;
+    const res = await ghRestPutStatus(token, `/repos/${owner}/${name}/pulls/${number}/merge`, body);
+    const j = (res.json ?? {});
+    if (res.ok && j.merged)
+        return { ok: true, sha: j.sha ?? '' };
+    const message = j.message ?? res.text.slice(0, 300);
+    const reason = res.status === 409
+        ? 'head_moved'
+        : res.status === 422
+            ? 'method_disallowed'
+            : res.status === 405
+                ? 'not_mergeable'
+                : 'error';
+    return { ok: false, reason, message };
+}
+// GitHub's NATIVE "update branch from base" (PUT .../update-branch) — a merge commit of the base
+// into the head. Cloud-safe, clone-free (the cloud path for update-from-trunk). Merge-only: there
+// is no native rebase. 202 = accepted; 422 = can't update — which GitHub uses BOTH for a stale
+// expected_head_sha (a head-moved race — its message mentions the expected head sha) AND for a
+// genuine can't-merge, so we disambiguate on the message.
+export async function updatePullRequestBranch(token, owner, name, number, expectedHeadSha) {
+    const body = expectedHeadSha ? { expected_head_sha: expectedHeadSha } : undefined;
+    const res = await ghRestPutStatus(token, `/repos/${owner}/${name}/pulls/${number}/update-branch`, body);
+    if (res.status === 202)
+        return { ok: true };
+    const j = (res.json ?? {});
+    const message = j.message ?? res.text.slice(0, 300);
+    const headMoved = res.status === 409 || /expected head sha/i.test(message);
+    const reason = headMoved ? 'head_moved' : res.status === 422 ? 'conflicts' : 'error';
+    return { ok: false, reason, message };
+}
 // The PR's unified diff via the REST API (Accept: application/vnd.github.diff) —
 // cloud-ready, per-account. Bounded implicitly by GitHub's own diff-size limit.
 export async function fetchPrUnifiedDiff(token, owner, name, number) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pierre-review",
-  "version": "0.1.59",
+  "version": "0.1.60",
   "description": "Dashboard for tracking your team's GitHub PR activity across repos — local (SQLite + gh) or self-hosted multi-tenant cloud (Postgres + GitHub App).",
   "type": "module",
   "author": "Alex Wakeman",