From ed8e259789fcebcc9fced0c25d1a9c267ba76a69 Mon Sep 17 00:00:00 2001
From: badcuban <108198679+badcuban@users.noreply.github.com>
Date: Sun, 6 Sep 2026 12:10:17 -0400
Subject: [PATCH 1/3] fix(web): composer pull request row loads whole, closes,
 and follows the merge queue

Four things the docked row got wrong once it was in daily use.

It drew in two beats: the number and chip first, then the project, branch and diff stat when the detail read landed seconds later. The listing behind the thread's own pull request already knows the branch and the size, and the project is the thread's own, so the row now draws whole from those and lets the detail sharpen them.

It could not be closed. A close control hides the row for that pull request in that thread for the session; a thread moving on to another pull request gets the row back.

"Merge when checks pass" took seconds to take a click, because the switch waited for the host to arm the merge and be re-read. It now flips on the click and rolls back only if the host refuses.

Once GitHub takes a pull request into its merge queue it drops the auto-merge instruction, so the switch read as off while the chip said Queued, and flipping it re-armed and disarmed the queue entry. The popover now shows "In the merge queue" instead of the switch. The detail read also keeps polling while a pull request is armed with nothing in its way, so the chip sees the queue take it and the merge land instead of waiting on the slow listing.
---
 apps/web/src/components/ChatView.browser.tsx  | 11 +++
 .../chat/ComposerPullRequestRow.tsx           | 75 +++++++++++++++----
 .../chat/composerPullRequest.logic.test.ts    | 68 +++++++++++++----
 .../chat/composerPullRequest.logic.ts         | 66 +++++++++++-----
 .../chat/composerPullRequestDismissals.ts     | 43 +++++++++++
 .../pull-requests/pullRequests.logic.test.ts  | 18 ++++-
 .../pull-requests/pullRequests.logic.ts       | 29 ++++++-
 .../components/sidebar/InboxRows.browser.tsx  |  2 +
 .../routes/_chat.$environmentId.$threadId.tsx | 38 +++++++++-
 9 files changed, 293 insertions(+), 57 deletions(-)
 create mode 100644 apps/web/src/components/chat/composerPullRequestDismissals.ts

diff --git a/apps/web/src/components/ChatView.browser.tsx b/apps/web/src/components/ChatView.browser.tsx
index 635727a0..aa05f576 100644
--- a/apps/web/src/components/ChatView.browser.tsx
+++ b/apps/web/src/components/ChatView.browser.tsx
@@ -3034,6 +3034,17 @@ describe("ChatView timeline estimator parity (full app)", () => {
           dock!.getBoundingClientRect().bottom - composerSurface!.getBoundingClientRect().top,
         ),
       ).toBeLessThan(2);
+
+      // Closing the row takes it off the composer; the notice stays docked.
+      row.querySelector<HTMLButtonElement>('button[aria-label^="Hide pull request"]')!.click();
+      await waitForElement(
+        () =>
+          document.querySelector('[data-composer-pull-request-row="true"]') === null
+            ? document.querySelector<HTMLElement>('[data-composer-notice-dock="true"]')
+            : null,
+        "The pull request row did not leave the composer.",
+      );
+      expect(document.querySelector("[data-composer-notice-severity]")).toBeTruthy();
     } finally {
       await mounted.cleanup();
     }
diff --git a/apps/web/src/components/chat/ComposerPullRequestRow.tsx b/apps/web/src/components/chat/ComposerPullRequestRow.tsx
index 745939ed..4f4699f9 100644
--- a/apps/web/src/components/chat/ComposerPullRequestRow.tsx
+++ b/apps/web/src/components/chat/ComposerPullRequestRow.tsx
@@ -18,13 +18,16 @@ import type {
   PullRequestRef,
 } from "@threadlines/contracts";
 import { useMutation, useQueryClient } from "@tanstack/react-query";
-import { ChevronDownIcon, ExternalLinkIcon } from "lucide-react";
+import { ChevronDownIcon, ExternalLinkIcon, XIcon } from "lucide-react";
 import { useState } from "react";
 
 import { isElectron } from "../../env";
 import { useSettings, updateSettings } from "../../hooks/useSettings";
 import { readLocalApi } from "../../localApi";
-import { pullRequestActionMutationOptions } from "../../lib/pullRequestsReactQuery";
+import {
+  pullRequestActionMutationOptions,
+  pullRequestQueryKeys,
+} from "../../lib/pullRequestsReactQuery";
 import { cn } from "../../lib/utils";
 import {
   PullRequestHoverCard,
@@ -36,7 +39,7 @@ import { Checkbox } from "../ui/checkbox";
 import { Popover, PopoverPopup, PopoverTrigger } from "../ui/popover";
 import { DiffStatLabel } from "./DiffStatLabel";
 import {
-  canToggleComposerAutoMerge,
+  composerAutoMergeControl,
   composerPullRequestCheckBuckets,
   composerPullRequestRow,
   pullRequestChecksUrl,
@@ -49,10 +52,14 @@ export interface ComposerPullRequest {
   readonly reference: PullRequestRef;
   /** What the sidebar badge and the tab already resolved. */
   readonly pullRequest: ThreadPullRequest;
+  /** The thread's project, which is the pull request's too. */
+  readonly projectTitle: string | null;
   /** The shared read behind the Pull request tab; absent until it lands. */
   readonly detail: PullRequestDetail | undefined;
   /** Opens the Pull request tab, the same place the sidebar badge goes. */
   readonly onOpen: () => void;
+  /** Closes the row for this pull request in this thread. */
+  readonly onDismiss: () => void;
 }
 
 const CHIP_TONE_CLASS: Readonly<
@@ -78,6 +85,7 @@ export function ComposerPullRequestRow({
 }) {
   const row = composerPullRequestRow({
     pullRequest: pullRequest.pullRequest,
+    projectTitle: pullRequest.projectTitle,
     detail: pullRequest.detail,
   });
   const tone = pullRequestBadgeTone(row.state, row.isDraft, row.autoMergeEnabled);
@@ -132,6 +140,14 @@ export function ComposerPullRequestRow({
         chip={row.chip}
         checksUrl={pullRequestChecksUrl(row.url)}
       />
+      <button
+        type="button"
+        aria-label={`Hide pull request #${row.number} from the composer`}
+        className="inline-flex size-5 shrink-0 cursor-pointer items-center justify-center rounded-md text-muted-foreground/70 transition-colors hover:text-foreground focus-ring"
+        onClick={pullRequest.onDismiss}
+      >
+        <XIcon className="size-3.5" />
+      </button>
     </div>
   );
 }
@@ -212,15 +228,39 @@ function ComposerPullRequestChecksPopover({
   const detail = pullRequest.detail;
   const buckets = composerPullRequestCheckBuckets(detail?.checks ?? []);
   const wrapUpOnSettled = useSettings((settings) => settings.wrapUpThreadsOnPullRequestSettled);
-  const autoMergeEnabled = detail?.autoMergeEnabled === true;
-  const canToggleAutoMerge = canToggleComposerAutoMerge(detail);
-  const action = useMutation(
-    pullRequestActionMutationOptions({
-      environmentId: pullRequest.environmentId,
-      reference: pullRequest.reference,
-      queryClient,
-    }),
+  const autoMergeControl = composerAutoMergeControl(detail);
+  const detailQueryKey = pullRequestQueryKeys.detail(
+    pullRequest.environmentId,
+    pullRequest.reference.projectId,
+    pullRequest.reference.number,
   );
+  const actionOptions = pullRequestActionMutationOptions({
+    environmentId: pullRequest.environmentId,
+    reference: pullRequest.reference,
+    queryClient,
+  });
+  const action = useMutation({
+    ...actionOptions,
+    // The switch flips the moment it is clicked. The host takes seconds to arm
+    // the merge and seconds more to be re-read, and a switch that waits for
+    // both reads as one that did not take the click. If the host refuses, the
+    // detail it was read from comes back.
+    onMutate: (variables) => {
+      const previous = queryClient.getQueryData<PullRequestDetail>(detailQueryKey);
+      if (previous && variables.action.endsWith("auto-merge")) {
+        queryClient.setQueryData<PullRequestDetail>(detailQueryKey, {
+          ...previous,
+          autoMergeEnabled: variables.action === "enable-auto-merge",
+        });
+      }
+      return { previous };
+    },
+    onError: (_error, _variables, context) => {
+      if (context?.previous) {
+        queryClient.setQueryData(detailQueryKey, context.previous);
+      }
+    },
+  });
 
   return (
     <div className="w-full py-2 text-xs">
@@ -270,12 +310,11 @@ function ComposerPullRequestChecksPopover({
         })
       )}
       <div className="my-1.5 border-border border-t" />
-      {canToggleAutoMerge ? (
+      {autoMergeControl.kind === "toggle" ? (
         <label className="flex cursor-pointer items-center gap-2 px-3 py-1 transition-colors hover:bg-accent">
           <Checkbox
             className="size-3.5"
-            checked={autoMergeEnabled}
-            disabled={action.isPending}
+            checked={autoMergeControl.checked}
             onCheckedChange={(checked) => {
               const next: PullRequestAction = checked ? "enable-auto-merge" : "disable-auto-merge";
               action.mutate({ action: next });
@@ -284,6 +323,14 @@ function ComposerPullRequestChecksPopover({
           Merge when checks pass
         </label>
       ) : null}
+      {autoMergeControl.kind === "queued" ? (
+        // The host has taken it: there is no instruction left to switch off,
+        // and the queue lands it on its own.
+        <p className="flex items-center gap-2 px-3 py-1 text-muted-foreground">
+          <ChipDot className={CHIP_TONE_CLASS.queued.dot + " " + CHIP_TONE_CLASS.queued.chip} />
+          In the merge queue
+        </p>
+      ) : null}
       <label className="flex cursor-pointer items-center gap-2 px-3 py-1 transition-colors hover:bg-accent">
         <Checkbox
           className="size-3.5"
diff --git a/apps/web/src/components/chat/composerPullRequest.logic.test.ts b/apps/web/src/components/chat/composerPullRequest.logic.test.ts
index a801ba61..6eda3fa5 100644
--- a/apps/web/src/components/chat/composerPullRequest.logic.test.ts
+++ b/apps/web/src/components/chat/composerPullRequest.logic.test.ts
@@ -3,7 +3,7 @@ import { describe, expect, it } from "vite-plus/test";
 
 import type { ThreadPullRequest } from "../pull-requests/pullRequests.logic";
 import {
-  canToggleComposerAutoMerge,
+  composerAutoMergeControl,
   composerPullRequestCheckBuckets,
   composerPullRequestChip,
   composerPullRequestRow,
@@ -18,6 +18,8 @@ const THREAD_PULL_REQUEST: ThreadPullRequest = {
   repository: "Threadlines/threadlines",
   settledAt: null,
   autoMergeEnabled: false,
+  headBranch: null,
+  diffStat: null,
 };
 
 function check(status: PullRequestCheck["status"], name: string): PullRequestCheck {
@@ -80,23 +82,44 @@ function detail(overrides: Partial<PullRequestDetail> = {}): PullRequestDetail {
 }
 
 describe("composerPullRequestRow", () => {
-  it("renders from the thread's own pull request before the detail arrives", () => {
-    const row = composerPullRequestRow({ pullRequest: THREAD_PULL_REQUEST, detail: undefined });
+  it("renders whole from the thread's own pull request before the detail arrives", () => {
+    const row = composerPullRequestRow({
+      pullRequest: {
+        ...THREAD_PULL_REQUEST,
+        headBranch: "fix/migration-050-backfill-speed",
+        diffStat: { additions: 26, deletions: 25 },
+      },
+      projectTitle: "threadlines",
+      detail: undefined,
+    });
 
     expect(row.number).toBe(234);
     expect(row.state).toBe("open");
     expect(row.title).toBe(THREAD_PULL_REQUEST.title);
-    // Nothing but the detail knows these, and a guessed branch or diff stat is
-    // worse than a row that simply has not filled in yet.
+    // The listing and the project already know these, so the row does not
+    // fill in a beat after it appears.
+    expect(row.headBranch).toBe("fix/migration-050-backfill-speed");
+    expect(row.projectTitle).toBe("threadlines");
+    expect(row.diffStat).toEqual({ additions: 26, deletions: 25 });
+    // Only the detail knows how the checks are going.
+    expect(row.chip).toEqual({ label: "CI", tone: "unknown", interactive: true });
+  });
+
+  it("leaves blank what no source has said rather than guessing", () => {
+    const row = composerPullRequestRow({
+      pullRequest: THREAD_PULL_REQUEST,
+      projectTitle: null,
+      detail: undefined,
+    });
     expect(row.headBranch).toBeNull();
     expect(row.projectTitle).toBeNull();
     expect(row.diffStat).toBeNull();
-    expect(row.chip).toEqual({ label: "CI", tone: "unknown", interactive: true });
   });
 
   it("takes the branch, project, size and state from the detail once it lands", () => {
     const row = composerPullRequestRow({
       pullRequest: THREAD_PULL_REQUEST,
+      projectTitle: null,
       // The listing behind the thread's resolution polls slowly, so a merge
       // shows up on the detail first and the row has to follow it.
       detail: detail({ state: "merged", checks: [check("success", "build")] }),
@@ -159,23 +182,38 @@ describe("composerPullRequestCheckBuckets", () => {
   });
 });
 
-describe("canToggleComposerAutoMerge", () => {
-  it("is off where the host does not say whether the pull request is armed", () => {
-    expect(canToggleComposerAutoMerge(detail({ autoMergeEnabled: null }))).toBe(false);
-    expect(canToggleComposerAutoMerge(undefined)).toBe(false);
+describe("composerAutoMergeControl", () => {
+  it("is hidden where the host does not say whether the pull request is armed", () => {
+    expect(composerAutoMergeControl(detail({ autoMergeEnabled: null }))).toEqual({
+      kind: "hidden",
+    });
+    expect(composerAutoMergeControl(undefined)).toEqual({ kind: "hidden" });
   });
 
-  it("is off where the host offers neither action", () => {
+  it("is hidden where the host offers neither action", () => {
     expect(
-      canToggleComposerAutoMerge(
+      composerAutoMergeControl(
         detail({
           capabilities: { ...detail().capabilities, actions: ["merge", "close"] },
         }),
       ),
-    ).toBe(false);
+    ).toEqual({ kind: "hidden" });
   });
 
-  it("is on where the host offers one of them", () => {
-    expect(canToggleComposerAutoMerge(detail())).toBe(true);
+  it("is a switch carrying the standing instruction where the host offers one of them", () => {
+    expect(composerAutoMergeControl(detail())).toEqual({ kind: "toggle", checked: false });
+    expect(composerAutoMergeControl(detail({ autoMergeEnabled: true }))).toEqual({
+      kind: "toggle",
+      checked: true,
+    });
+  });
+
+  it("stops being a switch once the host has taken the pull request into its queue", () => {
+    // GitHub drops the instruction on entry to the queue, so a switch would
+    // read as off while the merge is in motion, and flipping it would re-arm
+    // and disarm an entry that no longer needs it.
+    expect(
+      composerAutoMergeControl(detail({ autoMergeEnabled: false, mergeQueue: { position: 1 } })),
+    ).toEqual({ kind: "queued" });
   });
 });
diff --git a/apps/web/src/components/chat/composerPullRequest.logic.ts b/apps/web/src/components/chat/composerPullRequest.logic.ts
index 407d8109..f33e6527 100644
--- a/apps/web/src/components/chat/composerPullRequest.logic.ts
+++ b/apps/web/src/components/chat/composerPullRequest.logic.ts
@@ -3,9 +3,9 @@
  * feed it: the thread's own pull request (which the sidebar badge and the tab
  * already resolve) and, once it arrives, the detail the Pull request tab reads.
  *
- * The row renders from the first alone, so it appears with the thread rather
- * than a beat later, and gains its branch, its diff stat and its check rollup
- * when the detail lands.
+ * The row renders whole from the first: the listing behind it already knows
+ * the branch and the size, and the project is the thread's own. The detail
+ * only sharpens what is there and adds the check rollup.
  *
  * @module composerPullRequest.logic
  */
@@ -60,7 +60,6 @@ export interface ComposerPullRequestRowModel {
   readonly autoMergeEnabled: boolean;
   readonly title: string;
   readonly url: string;
-  /** Absent until the detail arrives. */
   readonly projectTitle: string | null;
   readonly headBranch: string | null;
   readonly diffStat: { readonly additions: number; readonly deletions: number } | null;
@@ -107,7 +106,7 @@ export function composerPullRequestChip(input: {
   if (detail === undefined) {
     return { label: "CI", tone: "unknown", interactive: true };
   }
-  if (detail.mergeQueue !== undefined && detail.mergeQueue.position !== null) {
+  if (isInMergeQueue(detail)) {
     return { label: "Queued", tone: "queued", interactive: true };
   }
   if (detail.checksState === undefined && detail.checks.length === 0) {
@@ -121,12 +120,15 @@ export function composerPullRequestChip(input: {
 }
 
 /**
- * The row for one thread's pull request. The state, number and title come from
- * the thread's own resolution so the row is never blank; everything the detail
- * alone knows waits for it rather than being guessed at.
+ * The row for one thread's pull request. Everything the thread's own
+ * resolution and its project know is drawn at once; the detail, which is a
+ * slower read, replaces those figures with fresher ones when it lands rather
+ * than being what the row waits for.
  */
 export function composerPullRequestRow(input: {
   readonly pullRequest: ThreadPullRequest;
+  /** The thread's project, which is the pull request's too. */
+  readonly projectTitle: string | null;
   readonly detail: PullRequestDetail | undefined;
 }): ComposerPullRequestRowModel {
   const { pullRequest, detail } = input;
@@ -140,26 +142,50 @@ export function composerPullRequestRow(input: {
     autoMergeEnabled: detail ? pullRequestArmedToMerge(detail) : pullRequest.autoMergeEnabled,
     title: detail?.title ?? pullRequest.title,
     url: detail?.url ?? pullRequest.url,
-    projectTitle: detail?.projectTitle ?? null,
-    headBranch: detail?.headBranch ?? null,
-    diffStat: detail ? { additions: detail.additions, deletions: detail.deletions } : null,
+    projectTitle: input.projectTitle ?? detail?.projectTitle ?? null,
+    headBranch: detail?.headBranch ?? pullRequest.headBranch,
+    diffStat: detail
+      ? { additions: detail.additions, deletions: detail.deletions }
+      : pullRequest.diffStat,
     chip: composerPullRequestChip({ state, detail }),
   };
 }
 
+function isInMergeQueue(detail: Pick<PullRequestDetail, "mergeQueue">): boolean {
+  return detail.mergeQueue !== undefined && detail.mergeQueue.position !== null;
+}
+
 /**
- * Whether the "Merge when checks pass" toggle has anything to do. A host that
- * does not say whether the pull request is armed cannot be asked to arm it,
- * and neither can one that offers neither action.
+ * What the popover shows in place of "Merge when checks pass".
+ *
+ * `toggle` is the ordinary case: the switch arms or disarms the host's standing
+ * instruction. `queued` is a pull request the host has already taken into its
+ * merge queue: GitHub drops the instruction at that point, so a switch would
+ * read as off while the merge is in motion, and flipping it would re-arm and
+ * disarm a queue entry that no longer needs it. `hidden` is a host that does
+ * not say whether the pull request is armed, or offers neither action.
  */
-export function canToggleComposerAutoMerge(detail: PullRequestDetail | undefined): boolean {
-  if (detail === undefined || detail.autoMergeEnabled === null) {
-    return false;
+export type ComposerAutoMergeControl =
+  | { readonly kind: "hidden" }
+  | { readonly kind: "queued" }
+  | { readonly kind: "toggle"; readonly checked: boolean };
+
+export function composerAutoMergeControl(
+  detail: PullRequestDetail | undefined,
+): ComposerAutoMergeControl {
+  if (detail === undefined) {
+    return { kind: "hidden" };
   }
-  return (
+  if (isInMergeQueue(detail)) {
+    return { kind: "queued" };
+  }
+  if (detail.autoMergeEnabled === null) {
+    return { kind: "hidden" };
+  }
+  const offered =
     detail.capabilities.actions.includes("enable-auto-merge") ||
-    detail.capabilities.actions.includes("disable-auto-merge")
-  );
+    detail.capabilities.actions.includes("disable-auto-merge");
+  return offered ? { kind: "toggle", checked: detail.autoMergeEnabled } : { kind: "hidden" };
 }
 
 /** The host's own checks page for a pull request. */
diff --git a/apps/web/src/components/chat/composerPullRequestDismissals.ts b/apps/web/src/components/chat/composerPullRequestDismissals.ts
new file mode 100644
index 00000000..a9d4f09b
--- /dev/null
+++ b/apps/web/src/components/chat/composerPullRequestDismissals.ts
@@ -0,0 +1,43 @@
+/**
+ * Which pull request rows the user has closed off the composer this session.
+ *
+ * A dismissal names one pull request in one thread, so the row comes back the
+ * moment the thread is working a different pull request. It is not persisted:
+ * the row is standing context, and a restart bringing it back is the way back
+ * in for someone who closed it by mistake.
+ *
+ * @module composerPullRequestDismissals
+ */
+import { create } from "zustand";
+
+const useComposerPullRequestDismissalStore = create<{
+  readonly dismissed: ReadonlySet<string>;
+  readonly dismiss: (key: string) => void;
+}>((set) => ({
+  dismissed: new Set(),
+  dismiss: (key) =>
+    set((current) =>
+      current.dismissed.has(key) ? current : { dismissed: new Set(current.dismissed).add(key) },
+    ),
+}));
+
+/** One pull request in one thread. */
+export function composerPullRequestDismissalKey(input: {
+  readonly threadKey: string;
+  readonly repository: string;
+  readonly number: number;
+}): string {
+  return `${input.threadKey}|${input.repository.toLowerCase()}#${input.number}`;
+}
+
+export function useIsComposerPullRequestDismissed(key: string | null): boolean {
+  return useComposerPullRequestDismissalStore((store) => key !== null && store.dismissed.has(key));
+}
+
+export function dismissComposerPullRequest(key: string): void {
+  useComposerPullRequestDismissalStore.getState().dismiss(key);
+}
+
+export function __resetComposerPullRequestDismissalsForTests(): void {
+  useComposerPullRequestDismissalStore.setState({ dismissed: new Set() });
+}
diff --git a/apps/web/src/components/pull-requests/pullRequests.logic.test.ts b/apps/web/src/components/pull-requests/pullRequests.logic.test.ts
index 009133e0..e7f922a0 100644
--- a/apps/web/src/components/pull-requests/pullRequests.logic.test.ts
+++ b/apps/web/src/components/pull-requests/pullRequests.logic.test.ts
@@ -516,6 +516,8 @@ describe("resolveThreadPullRequest", () => {
       repository: "threadlines/threadlines",
       settledAt: null,
       autoMergeEnabled: false,
+      headBranch: "feature/pull-requests",
+      diffStat: null,
     });
   });
 
@@ -1141,6 +1143,7 @@ describe("shouldPollPullRequestDetail", () => {
     state: "open" as const,
     mergeability: "mergeable" as const,
     updatedAt: "2026-09-04T11:00:00.000Z",
+    autoMergeEnabled: null,
   };
 
   it("polls while a check runs, and for a while after a push before any check exists", () => {
@@ -1172,12 +1175,23 @@ describe("shouldPollPullRequestDetail", () => {
     expect(shouldPollPullRequestDetail({ ...inQueue, mergeQueue: { position: 2 } }, now)).toBe(
       true,
     );
-    // Merely armed under a queue is a settled state: nothing moves until the
-    // requirements pass, which the checks already say.
     expect(shouldPollPullRequestDetail({ ...inQueue, mergeQueue: { position: null } }, now)).toBe(
       false,
     );
   });
+
+  it("keeps watching an armed pull request with nothing in its way", () => {
+    // The host can take or merge it at any moment, and the composer's chip and
+    // the sidebar badge are what say it happened.
+    const armed = { ...settled, checks: [check("success")], autoMergeEnabled: true };
+    expect(shouldPollPullRequestDetail({ ...armed, mergeGate: "clear" as const }, now)).toBe(true);
+    expect(shouldPollPullRequestDetail(armed, now)).toBe(true);
+    // Armed but blocked is a settled state: a review still owed does not
+    // clear itself, and reading every twenty seconds would only find that out.
+    expect(shouldPollPullRequestDetail({ ...armed, mergeGate: "blocked" as const }, now)).toBe(
+      false,
+    );
+  });
 });
 
 describe("handing a review comment to a thread", () => {
diff --git a/apps/web/src/components/pull-requests/pullRequests.logic.ts b/apps/web/src/components/pull-requests/pullRequests.logic.ts
index 8d440947..ec57be42 100644
--- a/apps/web/src/components/pull-requests/pullRequests.logic.ts
+++ b/apps/web/src/components/pull-requests/pullRequests.logic.ts
@@ -585,6 +585,10 @@ export interface ThreadPullRequest {
   readonly settledAt: string | null;
   /** Armed to merge on its own once its requirements pass; false where the source did not say. */
   readonly autoMergeEnabled: boolean;
+  /** The branch it merges from; null where the source did not say. */
+  readonly headBranch: string | null;
+  /** Lines added and removed; null where the source does not count them. */
+  readonly diffStat: { readonly additions: number; readonly deletions: number } | null;
 }
 
 /**
@@ -657,6 +661,9 @@ export function pullRequestFromGitStatus(
     // The status read carries no dates.
     settledAt: null,
     autoMergeEnabled: gitStatus.pr.autoMergeEnabled === true,
+    headBranch: gitStatus.pr.headRef,
+    // The status read does not count lines.
+    diffStat: null,
   };
 }
 
@@ -714,6 +721,8 @@ export function resolveThreadPullRequest(input: {
     // is at or after it.
     settledAt: entry.settledAt ?? (entry.state === "open" ? null : entry.updatedAt),
     autoMergeEnabled: entry.autoMergeEnabled === true,
+    headBranch: entry.headBranch,
+    diffStat: { additions: entry.additions, deletions: entry.deletions },
   };
 }
 
@@ -1585,11 +1594,23 @@ export const PULL_REQUEST_FRESH_PUSH_WATCH_MS = 120_000;
  * from the base, a new commit) when the host has the commit but has not queued
  * its checks or decided whether it merges: a read then shows no checks at all,
  * and would otherwise sit on that answer until the user hit Refresh. A pull
- * request sitting in a merge queue is the third: its place in the queue moves
- * on its own, and the host lands it without anyone here asking.
+ * request the host is landing on its own is the third: in a merge queue, or
+ * armed with nothing the host says is in the way, it can be queued or merged
+ * without anyone here asking, and the surfaces showing it should see that
+ * happen. Armed but blocked (a review still owed, a failed check) is a settled
+ * state: nothing moves until someone acts, and that act is re-read on its own.
  */
 export function shouldPollPullRequestDetail(
-  detail: Pick<PullRequestDetail, "state" | "checks" | "mergeability" | "updatedAt" | "mergeQueue">,
+  detail: Pick<
+    PullRequestDetail,
+    | "state"
+    | "checks"
+    | "mergeability"
+    | "updatedAt"
+    | "mergeQueue"
+    | "autoMergeEnabled"
+    | "mergeGate"
+  >,
   now: number,
 ): boolean {
   if (detail.checks.some((check) => check.status === "pending")) {
@@ -1598,7 +1619,7 @@ export function shouldPollPullRequestDetail(
   if (detail.state !== "open") {
     return false;
   }
-  if (detail.mergeQueue !== undefined && detail.mergeQueue.position !== null) {
+  if (pullRequestArmedToMerge(detail) && detail.mergeGate !== "blocked") {
     return true;
   }
   const unsettled = detail.checks.length === 0 || detail.mergeability === "unknown";
diff --git a/apps/web/src/components/sidebar/InboxRows.browser.tsx b/apps/web/src/components/sidebar/InboxRows.browser.tsx
index 3afb999b..3c8bc7da 100644
--- a/apps/web/src/components/sidebar/InboxRows.browser.tsx
+++ b/apps/web/src/components/sidebar/InboxRows.browser.tsx
@@ -59,6 +59,8 @@ const OPEN_PULL_REQUEST: ThreadPullRequest = {
   number: 123,
   state: "open",
   settledAt: null,
+  headBranch: null,
+  diffStat: null,
   isDraft: false,
   autoMergeEnabled: false,
   title: "Add the pull requests page",
diff --git a/apps/web/src/routes/_chat.$environmentId.$threadId.tsx b/apps/web/src/routes/_chat.$environmentId.$threadId.tsx
index 0db4554c..05b7f3f5 100644
--- a/apps/web/src/routes/_chat.$environmentId.$threadId.tsx
+++ b/apps/web/src/routes/_chat.$environmentId.$threadId.tsx
@@ -37,6 +37,11 @@ import {
 import { LazyPullRequestDetailPanel } from "../components/pull-requests/LazyPullRequestDetailPanel";
 import { PullRequestHoverCardProvider } from "../components/pull-requests/PullRequestHoverCard";
 import type { ComposerPullRequest } from "../components/chat/ComposerPullRequestRow";
+import {
+  composerPullRequestDismissalKey as composerPullRequestDismissalKeyFor,
+  dismissComposerPullRequest,
+  useIsComposerPullRequestDismissed,
+} from "../components/chat/composerPullRequestDismissals";
 import { resolveThreadPullRequest } from "../components/pull-requests/pullRequests.logic";
 import { Button } from "~/components/ui/button";
 import { Empty, EmptyContent, EmptyDescription, EmptyHeader } from "~/components/ui/empty";
@@ -493,18 +498,47 @@ function ChatThreadRouteView() {
     environmentId: threadPullRequestReference ? (threadRef?.environmentId ?? null) : null,
     reference: threadPullRequestReference,
   });
+  // Closing the row is per pull request: a thread that moves on to another one
+  // gets the row back for it.
+  const composerPullRequestDismissalKey =
+    threadPullRequestReference && currentThreadKey !== null
+      ? composerPullRequestDismissalKeyFor({
+          threadKey: currentThreadKey,
+          repository: threadPullRequestReference.repository,
+          number: threadPullRequestReference.number,
+        })
+      : null;
+  const composerPullRequestDismissed = useIsComposerPullRequestDismissed(
+    composerPullRequestDismissalKey,
+  );
+  const activeProjectTitle = activeProject?.name ?? null;
   const composerPullRequest = useMemo<ComposerPullRequest | null>(
     () =>
-      threadRef && threadPullRequest && threadPullRequestReference
+      threadRef &&
+      threadPullRequest &&
+      threadPullRequestReference &&
+      composerPullRequestDismissalKey !== null &&
+      !composerPullRequestDismissed
         ? {
             environmentId: threadRef.environmentId,
             reference: threadPullRequestReference,
             pullRequest: threadPullRequest,
+            projectTitle: activeProjectTitle,
             detail: threadPullRequestDetail,
             onOpen: () => selectTab("pullRequest"),
+            onDismiss: () => dismissComposerPullRequest(composerPullRequestDismissalKey),
           }
         : null,
-    [selectTab, threadPullRequest, threadPullRequestDetail, threadPullRequestReference, threadRef],
+    [
+      activeProjectTitle,
+      composerPullRequestDismissalKey,
+      composerPullRequestDismissed,
+      selectTab,
+      threadPullRequest,
+      threadPullRequestDetail,
+      threadPullRequestReference,
+      threadRef,
+    ],
   );
   const closeTab = useCallback(
     (tab: RightPanelTab) => {

From 4a296c1408cea2b4428ae6460be92fe8a2764252 Mon Sep 17 00:00:00 2001
From: badcuban <108198679+badcuban@users.noreply.github.com>
Date: Sun, 6 Sep 2026 12:27:06 -0400
Subject: [PATCH 2/3] fix(web): transcript pull request chips open the hover
 card and sit on the line

The chip in a transcript never showed the card the composer row shows, because the link component it renders through dropped every prop it did not know about, and the hover trigger's ref and pointer handlers were among them. The anchor's own props now ride through, so a trigger or tooltip wrapping a link reaches the element.

The chip also drew the transcript link underline through itself and sat a pixel high, aligned to the baseline of its smaller text. It now aligns to the middle of the line and carries no underline.
---
 apps/web/src/components/ChatMarkdown.tsx     |  2 +-
 apps/web/src/components/ChatView.browser.tsx | 33 +++++++++++++++---
 apps/web/src/components/chat/ChatWebLink.tsx | 36 +++++++++++++++-----
 apps/web/src/index.css                       |  6 ++++
 4 files changed, 64 insertions(+), 13 deletions(-)

diff --git a/apps/web/src/components/ChatMarkdown.tsx b/apps/web/src/components/ChatMarkdown.tsx
index f74e5f90..7295480b 100644
--- a/apps/web/src/components/ChatMarkdown.tsx
+++ b/apps/web/src/components/ChatMarkdown.tsx
@@ -625,7 +625,7 @@ function MarkdownPullRequestChip({
         href={href}
         threadRef={threadRef}
         title={title}
-        className="inline-flex items-center gap-1 rounded-sm bg-muted px-1.5 font-mono text-[12px] no-underline transition-colors hover:bg-accent"
+        className="chat-markdown-pull-request-chip inline-flex items-center gap-1 rounded-sm bg-muted px-1.5 align-middle font-mono text-[12px] transition-colors hover:bg-accent"
       >
         <tone.Icon aria-hidden className={cn("size-3 shrink-0", tone.className)} />
         <span>#{number}</span>
diff --git a/apps/web/src/components/ChatView.browser.tsx b/apps/web/src/components/ChatView.browser.tsx
index aa05f576..47e408c0 100644
--- a/apps/web/src/components/ChatView.browser.tsx
+++ b/apps/web/src/components/ChatView.browser.tsx
@@ -2983,12 +2983,20 @@ describe("ChatView timeline estimator parity (full app)", () => {
   });
 
   it("docks the thread's pull request above the notices in one frame", async () => {
+    const snapshot = createSnapshotForTargetUser({
+      targetMessageId: "msg-user-pull-request-dock" as MessageId,
+      targetText: "pull request dock",
+    });
+    // The transcript opens at its end, so the address that becomes a chip goes
+    // in the last message, where it is on screen.
+    const lastMessage = snapshot.threads[0]!.messages.at(-1)!;
+    snapshot.threads[0]!.messages[snapshot.threads[0]!.messages.length - 1] = {
+      ...lastMessage,
+      text: `Opened ${PULL_REQUEST_URL} for review.`,
+    };
     const mounted = await mountChatView({
       viewport: DEFAULT_VIEWPORT,
-      snapshot: createSnapshotForTargetUser({
-        targetMessageId: "msg-user-pull-request-dock" as MessageId,
-        targetText: "pull request dock",
-      }),
+      snapshot,
       configureFixture: withPullRequestFixture,
       resolveRpc: resolvePullRequestRpc,
     });
@@ -3035,6 +3043,23 @@ describe("ChatView timeline estimator parity (full app)", () => {
         ),
       ).toBeLessThan(2);
 
+      // The address in the message is a chip, and the chip shares the row's
+      // hover card: the trigger has to reach the anchor through the link
+      // component, which is the part that silently broke once.
+      const chip = await waitForElement(
+        () => document.querySelector<HTMLAnchorElement>("a.chat-markdown-pull-request-chip"),
+        "Unable to find the pull request chip in the transcript.",
+      );
+      expect(chip.textContent).toBe(`#${PULL_REQUEST_NUMBER}`);
+      await page.elementLocator(chip).hover();
+      const card = await waitForElement(
+        () => document.querySelector<HTMLElement>('[data-testid="pull-request-hover-card"]'),
+        "Hovering the transcript chip did not open the pull request card.",
+      );
+      expect(card.textContent).toContain(`${PULL_REQUEST_REPOSITORY} #${PULL_REQUEST_NUMBER}`);
+      // Move off so the card does not sit over the row's close control.
+      await page.elementLocator(composerSurface!).hover();
+
       // Closing the row takes it off the composer; the notice stays docked.
       row.querySelector<HTMLButtonElement>('button[aria-label^="Hide pull request"]')!.click();
       await waitForElement(
diff --git a/apps/web/src/components/chat/ChatWebLink.tsx b/apps/web/src/components/chat/ChatWebLink.tsx
index 961ebce8..41b126f4 100644
--- a/apps/web/src/components/chat/ChatWebLink.tsx
+++ b/apps/web/src/components/chat/ChatWebLink.tsx
@@ -1,5 +1,11 @@
 import type { ScopedThreadRef } from "@threadlines/contracts";
-import { memo, useCallback, type MouseEvent as ReactMouseEvent, type ReactNode } from "react";
+import {
+  memo,
+  useCallback,
+  type ComponentProps,
+  type MouseEvent as ReactMouseEvent,
+  type ReactNode,
+} from "react";
 
 import { isElectron } from "../../env";
 import { readLocalApi } from "../../localApi";
@@ -9,7 +15,15 @@ import { stackedThreadToast, toastManager } from "../ui/toast";
 import { copyTextWithToast } from "./copyTextWithToast";
 import { useThreadPullRequestLink } from "./ThreadPullRequestLinkContext";
 
-export interface ChatWebLinkProps {
+/**
+ * The anchor's own props ride along, `ref` included, so a hover-card trigger
+ * or tooltip can wrap the link and reach the element: a wrapper that dropped
+ * them would leave the card with nothing to listen to.
+ */
+export interface ChatWebLinkProps extends Omit<
+  ComponentProps<"a">,
+  "href" | "children" | "className" | "title"
+> {
   href: string;
   /** Null when the transcript is rendered without a thread to open pages in. */
   threadRef: ScopedThreadRef | null;
@@ -36,6 +50,9 @@ export const ChatWebLink = memo(function ChatWebLink({
   children,
   className,
   title,
+  onClick,
+  onContextMenu,
+  ...anchorProps
 }: ChatWebLinkProps) {
   const pullRequestLink = useThreadPullRequestLink();
   const opensPullRequestTab =
@@ -43,7 +60,8 @@ export const ChatWebLink = memo(function ChatWebLink({
 
   const handleClick = useCallback(
     (event: ReactMouseEvent<HTMLAnchorElement>) => {
-      if (!isPlainPrimaryClick(event)) {
+      onClick?.(event);
+      if (event.defaultPrevented || !isPlainPrimaryClick(event)) {
         return;
       }
       if (opensPullRequestTab) {
@@ -61,13 +79,14 @@ export const ChatWebLink = memo(function ChatWebLink({
       event.preventDefault();
       event.stopPropagation();
     },
-    [href, opensPullRequestTab, pullRequestLink, threadRef],
+    [href, onClick, opensPullRequestTab, pullRequestLink, threadRef],
   );
 
   const handleContextMenu = useCallback(
     async (event: ReactMouseEvent<HTMLAnchorElement>) => {
+      onContextMenu?.(event);
       const api = readLocalApi();
-      if (!api) return;
+      if (!api || event.defaultPrevented) return;
 
       event.preventDefault();
       event.stopPropagation();
@@ -105,16 +124,17 @@ export const ChatWebLink = memo(function ChatWebLink({
         copyTextWithToast(href, "Link address");
       }
     },
-    [href, opensPullRequestTab, threadRef],
+    [href, onContextMenu, opensPullRequestTab, threadRef],
   );
 
   return (
     <a
+      target="_blank"
+      rel="noopener noreferrer"
+      {...anchorProps}
       href={href}
       className={className}
       title={title}
-      target="_blank"
-      rel="noopener noreferrer"
       onClick={handleClick}
       onContextMenu={handleContextMenu}
     >
diff --git a/apps/web/src/index.css b/apps/web/src/index.css
index 854c0aad..df5b66e5 100644
--- a/apps/web/src/index.css
+++ b/apps/web/src/index.css
@@ -633,6 +633,12 @@ label:has(> select#reasoning-effort) select {
   opacity: 0.8;
 }
 
+/* A pull request chip is a link drawn as a badge: the badge carries the
+   affordance, so the underline would only cut through it. */
+.chat-markdown a.chat-markdown-pull-request-chip {
+  text-decoration: none;
+}
+
 .chat-markdown blockquote {
   border-left: 2px solid var(--border);
   padding-left: 0.8rem;

From 3c97b1e4b089015b7393aab9b82f9041a4f1830a Mon Sep 17 00:00:00 2001
From: badcuban <108198679+badcuban@users.noreply.github.com>
Date: Sun, 6 Sep 2026 12:28:09 -0400
Subject: [PATCH 3/3] test(web): build the chip transcript snapshot without
 mutating it

---
 apps/web/src/components/ChatView.browser.tsx | 20 +++++++++++++++-----
 1 file changed, 15 insertions(+), 5 deletions(-)

diff --git a/apps/web/src/components/ChatView.browser.tsx b/apps/web/src/components/ChatView.browser.tsx
index 47e408c0..4cec8a7b 100644
--- a/apps/web/src/components/ChatView.browser.tsx
+++ b/apps/web/src/components/ChatView.browser.tsx
@@ -2983,16 +2983,26 @@ describe("ChatView timeline estimator parity (full app)", () => {
   });
 
   it("docks the thread's pull request above the notices in one frame", async () => {
-    const snapshot = createSnapshotForTargetUser({
+    const built = createSnapshotForTargetUser({
       targetMessageId: "msg-user-pull-request-dock" as MessageId,
       targetText: "pull request dock",
     });
     // The transcript opens at its end, so the address that becomes a chip goes
     // in the last message, where it is on screen.
-    const lastMessage = snapshot.threads[0]!.messages.at(-1)!;
-    snapshot.threads[0]!.messages[snapshot.threads[0]!.messages.length - 1] = {
-      ...lastMessage,
-      text: `Opened ${PULL_REQUEST_URL} for review.`,
+    const snapshot: OrchestrationReadModel = {
+      ...built,
+      threads: built.threads.map((thread, threadIndex) =>
+        threadIndex === 0
+          ? {
+              ...thread,
+              messages: thread.messages.map((message, index, all) =>
+                index === all.length - 1
+                  ? { ...message, text: `Opened ${PULL_REQUEST_URL} for review.` }
+                  : message,
+              ),
+            }
+          : thread,
+      ),
     };
     const mounted = await mountChatView({
       viewport: DEFAULT_VIEWPORT,