@@ -635,7 +635,11 @@ describe("PullRequestSyncReactor", () => {
         yield* TestClock.setTime(Date.parse(NOW));
         const fixture = yield* makeHarness({
           snapshot: makeSnapshot([
-            makeThread("merged", { pullRequests: [makeLink(1, { state: "merged" })] }),
+            makeThread("merged", {
+              pullRequests: [
+                makeLink(1, { state: "merged", mergedAt: "2026-08-27T00:00:00.000Z" }),
+              ],
+            }),
           ]),
         });
 
@@ -663,6 +667,33 @@ describe("PullRequestSyncReactor", () => {
     ),
   );
 
+  it.effect("re-reads a merged pull request until the host supplies its merge time", () =>
+    Effect.scoped(
+      Effect.gen(function* () {
+        yield* TestClock.setTime(Date.parse(NOW));
+        const fixture = yield* makeHarness({
+          snapshot: makeSnapshot([
+            makeThread("merged", { pullRequests: [makeLink(1, { state: "merged" })] }),
+          ]),
+          summary: (input) =>
+            Effect.succeed(
+              makeSummary(input, { state: "merged", mergedAt: "2026-08-27T00:00:00.000Z" }),
+            ),
+        });
+
+        yield* Effect.gen(function* () {
+          const reactor = yield* startAndSweep(fixture);
+          const firstSweep = yield* Ref.get(fixture.syncCommands);
+          assert.strictEqual(firstSweep.at(-1)?.snapshot.mergedAt, "2026-08-27T00:00:00.000Z");
+          yield* Ref.update(fixture.snapshots, (snapshot) => applySync(snapshot, firstSweep));
+
+          for (let index = 0; index < 15; index += 1) yield* sweepAgain(fixture, reactor);
+          assert.strictEqual((yield* Ref.get(fixture.summaryCalls)).length, 1);
+        }).pipe(Effect.provide(fixture.layer));
+      }),
+    ),
+  );
+
   it.effect("syncs a pull request a reader saw merge without waiting for the sweep", () =>
     Effect.scoped(
       Effect.gen(function* () {
 
@@ -177,7 +177,15 @@ export const make = Effect.gen(function* () {
     // Settled threads stop watching their pull requests. Unsettling one makes its links due on
     // the next sweep, since the cadence clock below kept running while it was settled.
     const active = entries.filter((entry) => isUnsettled(entry.thread));
-    if (active.every((entry) => entry.link.snapshot?.state === "merged")) return false;
+    // A merged snapshot without its merge time cannot settle the thread, so it keeps the slow
+    // cadence until the host supplies one (Bitbucket snapshots saved before it was read).
+    if (
+      active.every(
+        (entry) => entry.link.snapshot?.state === "merged" && entry.link.snapshot.mergedAt != null,
+      )
+    ) {
+      return false;
+    }
     if (active.some((entry) => entry.link.snapshot?.state === "open")) return true;
     // Closed requests can reopen on the host.
     const last = lastSyncedAt.get(key);
 
@@ -730,6 +730,24 @@ layer("BitbucketPullRequestApi.layer", (it) => {
     }),
   );
 
+  it.effect("asks for the time a pull request closed, which Bitbucket leaves out by default", () =>
+    Effect.gen(function* () {
+      mockedRequest.mockReturnValueOnce(
+        Effect.succeed(
+          response(
+            pullRequestJson({ state: "MERGED", closed_on: "2025-06-16T23:40:46.222238+00:00" }),
+          ),
+        ),
+      );
+      const api = yield* BitbucketPullRequestApi.BitbucketPullRequestApi;
+
+      const pullRequest = yield* api.getPullRequest({ repository: "acme/web", number: 7 });
+
+      expect(callAt(0).url).toBe("/repositories/acme/web/pullrequests/7?fields=%2Bclosed_on");
+      assert.strictEqual(pullRequest.closedAt, "2025-06-16T23:40:46.222Z");
+    }),
+  );
+
   it.effect("fails the read when Bitbucket answers with something unreadable", () =>
     Effect.gen(function* () {
       mockedRequest.mockReturnValueOnce(
 
@@ -654,7 +654,9 @@ export const make = Effect.gen(function* () {
       withRepository(input.repository, (path) =>
         readPage({
           operation: "getPullRequest",
-          url: `${path}/pullrequests/${input.number}`,
+          // `closed_on` is left out of the default representation. It is the only merge or
+          // decline time Bitbucket states on the pull request itself, and settlement needs it.
+          url: `${path}/pullrequests/${input.number}?fields=%2Bclosed_on`,
           decode: decodePullRequestJson,
         }),
       ),
 
@@ -70,6 +70,53 @@ it.effect.each([
   }),
 );
 
+it.effect.each([
+  { state: "MERGED", mergedAt: "2025-06-16T23:40:46.222Z", closedAt: null },
+  { state: "DECLINED", mergedAt: null, closedAt: "2025-06-16T23:40:46.222Z" },
+  { state: "OPEN", mergedAt: null, closedAt: null },
+])("reads the $state time from closed_on", ({ state, mergedAt, closedAt }) =>
+  Effect.gen(function* () {
+    const pullRequest = Result.getOrThrow(
+      decodePullRequestJson(
+        JSON.stringify({
+          id: 52,
+          title: "Release",
+          state,
+          source: { branch: { name: "release" } },
+          destination: { branch: { name: "master" } },
+          created_on: "2025-06-16T06:20:58.415108+00:00",
+          // Comments after a merge move this, so it is not the merge time.
+          updated_on: "2025-06-20T10:00:00.000000+00:00",
+          closed_on: state === "OPEN" ? null : "2025-06-16T23:40:46.222238+00:00",
+          links: { html: { href: "https://bitbucket.org/acme/web/pull-requests/52" } },
+        }),
+      ),
+    );
+    const provider = yield* make.pipe(
+      Effect.provide(
+        Layer.mock(BitbucketPullRequestApi.BitbucketPullRequestApi)({
+          getPullRequest: () => Effect.succeed(pullRequest),
+          getDiffStat: () => Effect.succeed({ additions: 0, deletions: 0, changedFiles: 0 }),
+          getMergeability: () => Effect.succeed("unknown"),
+          listChecks: () => Effect.succeed([]),
+          getRepositoryPermission: () => Effect.succeed(true),
+        }),
+      ),
+    );
+    const detail = yield* provider.getChangeRequest({
+      cwd: "/repo",
+      repository: "acme/web",
+      host: "bitbucket.org",
+      number: 52,
+    });
+
+    expect({ mergedAt: detail.mergedAt, closedAt: detail.closedAt }).toEqual({
+      mergedAt,
+      closedAt,
+    });
+  }),
+);
+
 for (const operation of [
   "getMergeability",
   "listChecks",
 
@@ -221,8 +221,8 @@ export const make = Effect.gen(function* () {
             deletions: diffStat.deletions,
             changedFiles: diffStat.changedFiles,
             body: pullRequest.body,
-            mergedAt: null,
-            closedAt: null,
+            mergedAt: pullRequest.state === "merged" ? pullRequest.closedAt : null,
+            closedAt: pullRequest.state === "closed" ? pullRequest.closedAt : null,
             reviewers: pullRequest.reviewers,
             checks,
             // Bitbucket publishes no per-repository list of allowed strategies, so the ones it
 
@@ -71,6 +71,8 @@ const RawPullRequestSchema = Schema.Struct({
   destination: RawBranchSchema,
   created_on: Schema.String,
   updated_on: Schema.String,
+  /** Only sent when asked for with `fields=+closed_on`; null while the request is open. */
+  closed_on: Schema.optional(Schema.NullOr(Schema.String)),
   reviewers: Schema.optional(Schema.NullOr(Schema.Array(RawUserSchema))),
   participants: Schema.optional(
     Schema.NullOr(
@@ -192,6 +194,8 @@ export interface BitbucketPullRequest {
   readonly mergeability: PullRequestMergeability;
   readonly createdAt: string;
   readonly updatedAt: string;
+  /** When the request was merged or declined, unlike `updatedAt`, which later comments move. */
+  readonly closedAt: string | null;
   readonly body: string;
   readonly reviewRequestLogins: ReadonlyArray<string>;
   readonly reviewers: ReadonlyArray<PullRequestActor>;
@@ -304,6 +308,7 @@ function toPullRequest(raw: Schema.Schema.Type<typeof RawPullRequestSchema>): Bi
     mergeability: "unknown",
     createdAt: toIsoUtc(raw.created_on),
     updatedAt: toIsoUtc(raw.updated_on),
+    closedAt: raw.closed_on == null ? null : toIsoUtc(raw.closed_on),
     body: raw.description ?? "",
     reviewRequestLogins: reviewers.map((reviewer) => reviewer.login),
     reviewers,