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 635727a0..4cec8a7b 100644
--- a/apps/web/src/components/ChatView.browser.tsx
+++ b/apps/web/src/components/ChatView.browser.tsx
@@ -2983,12 +2983,30 @@ describe("ChatView timeline estimator parity (full app)", () => {
   });
 
   it("docks the thread's pull request above the notices in one frame", async () => {
+    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 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,
-      snapshot: createSnapshotForTargetUser({
-        targetMessageId: "msg-user-pull-request-dock" as MessageId,
-        targetText: "pull request dock",
-      }),
+      snapshot,
       configureFixture: withPullRequestFixture,
       resolveRpc: resolvePullRequestRpc,
     });
@@ -3034,6 +3052,34 @@ describe("ChatView timeline estimator parity (full app)", () => {
           dock!.getBoundingClientRect().bottom - composerSurface!.getBoundingClientRect().top,
         ),
       ).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(
+        () =>
+          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/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/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/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;
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) => {