fix(server): wake GitLab MR watches when a rebase is required

apps/server/src/orchestration-v2/Orchestrator.ts

@@ -5022,6 +5022,7 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
                       passed: existing.endedWatch.passed,
                       passedChecks: existing.endedWatch.passedChecks,
                       conflicting: existing.endedWatch.conflicting,
+                      rebaseRequired: existing.endedWatch.rebaseRequired,
                     }),
                     awaitingBaseline: existing.endedWatch
                       ? existing.endedWatch.awaitingBaseline

apps/server/src/orchestration-v2/PullRequestSyncReactor.test.ts

@@ -613,6 +613,39 @@ describe("PullRequestSyncReactor", () => {
       }).pipe(Effect.provide(fixture.layer));
     }),
   );
+  it.effect("syncs a rebase blocker even when the PR timestamp is unchanged", () =>
+    Effect.scoped(
+      Effect.gen(function* () {
+        yield* TestClock.setTime(Date.parse(NOW));
+        const required = yield* Ref.make(false);
+        const fixture = yield* makeHarness({
+          snapshot: makeSnapshot([makeThread("rebase", { pullRequests: [makeLink(7)] })]),
+          summary: (input) =>
+            Ref.get(required).pipe(
+              Effect.map((rebaseRequired) => makeSummary(input, { rebaseRequired })),
+            ),
+        });
+        yield* Effect.gen(function* () {
+          const reactor = yield* startAndSweep(fixture);
+          yield* applyRecordedSyncs(fixture);
+          yield* Ref.set(required, true);
+          yield* reactor.requestSync({
+            host: "github.com",
+            repository: "owner/repository",
+            number: 7,
+          });
+          yield* Queue.take(fixture.snapshotReads);
+          yield* reactor.drain;
+          const commands = yield* Ref.get(fixture.syncCommands);
+          assert.equal(commands.length, 2);
+          assert.equal(commands[0]?.snapshot?.rebaseRequired, false);
+          assert.equal(commands[1]?.snapshot?.rebaseRequired, true);
+          assert.equal(commands[0]?.snapshot?.updatedAt, commands[1]?.snapshot?.updatedAt);
+        }).pipe(Effect.provide(fixture.layer));
+      }),
+    ),
+  );
+
   it.effect("snapshots an unsynced link once and writes it to the thread", () =>
     Effect.gen(function* () {
       yield* TestClock.setTime(Date.parse(NOW));

apps/server/src/orchestration-v2/PullRequestSyncReactor.ts

@@ -234,6 +234,7 @@ function snapshotFieldsOf(summary: PullRequestSummary): SnapshotFields {
     ...(summary.reviewDecision === undefined ? {} : { reviewDecision: summary.reviewDecision }),
     ...(summary.checksState === undefined ? {} : { checksState: summary.checksState }),
     ...(summary.mergeability === undefined ? {} : { mergeability: summary.mergeability }),
+    ...(summary.rebaseRequired === undefined ? {} : { rebaseRequired: summary.rebaseRequired }),
   };
 }
 
@@ -282,7 +283,8 @@ function snapshotFieldsEqual(left: SnapshotFields, right: SnapshotFields): boole
     left.changedFiles === right.changedFiles &&
     (left.reviewDecision ?? null) === (right.reviewDecision ?? null) &&
     (left.checksState ?? null) === (right.checksState ?? null) &&
-    left.mergeability === right.mergeability
+    left.mergeability === right.mergeability &&
+    left.rebaseRequired === right.rebaseRequired
   );
 }
 

apps/server/src/orchestration-v2/PullRequestWatchReactor.ts

@@ -151,6 +151,7 @@ const snapshotFingerprint = ({ link }: WatchTarget) => {
         snapshot.updatedAt,
         snapshot.checksState,
         snapshot.mergeability,
+        snapshot.rebaseRequired,
         snapshot.reviewDecision,
         snapshot.isDraft,
       ].join(" ");
@@ -212,6 +213,7 @@ function watchesEqual(left: ThreadPullRequestWatch, right: ThreadPullRequestWatc
     left.remarksThrough === right.remarksThrough &&
     left.remarkIds.join("\n") === right.remarkIds.join("\n") &&
     left.conflicting === right.conflicting &&
+    left.rebaseRequired === right.rebaseRequired &&
     left.mergeQueueRemovalId === right.mergeQueueRemovalId &&
     left.wakes === right.wakes &&
     left.awaitingBaseline === right.awaitingBaseline &&

apps/server/src/orchestration-v2/pullRequestWatch.test.ts

@@ -81,6 +81,45 @@ const remark = (
 const noRemarks: ReadonlyArray<PullRequestComment> = [];
 
 describe("evaluatePullRequestWatch", () => {
+  it.each(["pending", "success"] as const)(
+    "reports a required rebase once with %s CI",
+    (status) => {
+      const blocked = detail({
+        mergeability: "unknown",
+        rebaseRequired: true,
+        checks: [check("test", status)],
+      });
+      const first = evaluatePullRequestWatch(watch(), blocked, noRemarks);
+      assert.include(
+        first.changes.map((change) => change.kind),
+        "needs-rebase",
+      );
+      assert.deepEqual(evaluatePullRequestWatch(first.next, blocked, noRemarks).changes, []);
+      const unknown = evaluatePullRequestWatch(
+        first.next,
+        { ...blocked, rebaseRequired: undefined },
+        noRemarks,
+      );
+      assert.deepEqual(evaluatePullRequestWatch(unknown.next, blocked, noRemarks).changes, []);
+      const clean = evaluatePullRequestWatch(
+        first.next,
+        { ...blocked, rebaseRequired: false },
+        noRemarks,
+      );
+      assert.deepEqual(evaluatePullRequestWatch(clean.next, blocked, noRemarks).changes, [
+        { kind: "needs-rebase" },
+      ]);
+      assert.include(
+        evaluatePullRequestWatch(
+          first.next,
+          { ...blocked, headSha: "bbbbbbbbbb" },
+          noRemarks,
+        ).changes.map((change) => change.kind),
+        "needs-rebase",
+      );
+    },
+  );
+
   it.each([false, true])("baselines already-passed checks (required: %s)", (required) => {
     const green = detail({ checks: [{ ...check("test", "success"), required }] });
     const baseline = evaluatePullRequestWatch(watch({ awaitingBaseline: "all" }), green, noRemarks);
@@ -115,6 +154,7 @@ describe("evaluatePullRequestWatch", () => {
     const broken = detail({
       checks: [check("lint", "failure"), check("test", "pending")],
       mergeability: "conflicting",
+      rebaseRequired: true,
     });
     const baseline = evaluatePullRequestWatch(
       watch({ awaitingBaseline: "all" }),
@@ -125,6 +165,7 @@ describe("evaluatePullRequestWatch", () => {
     assert.deepEqual(baseline.next.failedChecks, ["lint"]);
     assert.isFalse(baseline.next.passed);
     assert.isTrue(baseline.next.conflicting);
+    assert.isTrue(baseline.next.rebaseRequired);
     assert.deepEqual(evaluatePullRequestWatch(baseline.next, broken, noRemarks).changes, []);
 
     const failed = evaluatePullRequestWatch(
@@ -135,11 +176,16 @@ describe("evaluatePullRequestWatch", () => {
     assert.deepEqual(failed.changes, [
       { kind: "checks-failed", failed: [check("test", "failure")] },
     ]);
-    const clean = evaluatePullRequestWatch(failed.next, detail(), noRemarks);
+    const clean = evaluatePullRequestWatch(
+      failed.next,
+      detail({ rebaseRequired: false }),
+      noRemarks,
+    );
     assert.deepEqual(clean.changes, []);
     assert.deepEqual(evaluatePullRequestWatch(clean.next, broken, noRemarks).changes, [
       { kind: "checks-failed", failed: [check("lint", "failure")] },
       { kind: "conflicting" },
+      { kind: "needs-rebase" },
     ]);
   });
 

apps/server/src/orchestration-v2/pullRequestWatch.ts

@@ -21,6 +21,7 @@ export type PullRequestWatchChange =
   | { readonly kind: "remarks"; readonly remarks: ReadonlyArray<PullRequestComment> }
   | { readonly kind: "no-checks"; readonly minutes: number }
   | { readonly kind: "conflicting" }
+  | { readonly kind: "needs-rebase" }
   | { readonly kind: "merge-queue-removed"; readonly reason: string | null };
 
 export interface PullRequestWatchReport {
@@ -46,6 +47,7 @@ export function evaluatePullRequestWatch(
     | "mergeability"
     | "viewer"
     | "author"
+    | "rebaseRequired"
     | "mergeQueueRemoval"
   >,
   remarks: ReadonlyArray<PullRequestComment> | null,
@@ -196,11 +198,16 @@ export function evaluatePullRequestWatch(
     ...atLatest.map((remark) => remark.id),
   ];
 
-  // Like a failed check, a conflict a push did not resolve is news for the new head.
+  // Like a failed check, a conflict or rebase a push did not resolve is news for the new head.
   const toldConflict = !headMoved && watch.conflicting;
   if (watch.awaitingBaseline !== "all" && detail.mergeability === "conflicting" && !toldConflict) {
     changes.push({ kind: "conflicting" });
   }
+  const toldRebase = !headMoved && watch.rebaseRequired === true;
+  if (watch.awaitingBaseline !== "all" && detail.rebaseRequired === true && !toldRebase) {
+    changes.push({ kind: "needs-rebase" });
+  }
+  const rebaseRequired = detail.rebaseRequired ?? watch.rebaseRequired;
   // "unknown" is a host still computing after a push; only a clean answer clears a conflict.
   const conflicting =
     detail.mergeability === "unknown" ? toldConflict : detail.mergeability === "conflicting";
@@ -239,6 +246,7 @@ export function evaluatePullRequestWatch(
       remarksThrough,
       remarkIds,
       conflicting,
+      rebaseRequired,
       mergeQueueRemovalId,
       wakes,
       // Only a read that cannot be trusted to show the checks leaves the baseline to the next one.
@@ -308,6 +316,8 @@ function changeLines(
       return [
         `- No checks have reported${context.commit} after ${change.minutes} minutes. None may be configured to run on this change.`,
       ];
+    case "needs-rebase":
+      return [`- The branch requires a rebase onto ${context.baseBranch}.`];
     case "conflicting":
       return [`- The branch now conflicts with ${context.baseBranch}.`];
     case "merge-queue-removed":
@@ -324,6 +334,7 @@ const SUMMARY: Record<PullRequestWatchChange["kind"], string> = {
   remarks: "new comments",
   "no-checks": "no checks reported",
   conflicting: "merge conflict",
+  "needs-rebase": "rebase required",
   "merge-queue-removed": "removed from merge queue",
 };
 
@@ -388,6 +399,7 @@ export function pullRequestWatchMessage(input: {
     (change) =>
       change.kind === "checks-failed" ||
       change.kind === "conflicting" ||
+      change.kind === "needs-rebase" ||
       change.kind === "merge-queue-removed",
   );
   const summary = changes.map((change) => SUMMARY[change.kind]);

apps/server/src/pullRequest/PullRequestService.test.ts

@@ -3458,6 +3458,7 @@ it.effect(
               Effect.succeed({
                 ...changeRequest(1, "2026-07-02T00:00:00Z"),
                 isDraft: true,
+                rebaseRequired: false,
                 reviewDecision: "approved",
                 checksState: "passing",
               }),
@@ -3467,13 +3468,16 @@ it.effect(
                 deletions: 3,
                 changedFiles: 5,
                 mergeability: "conflicting",
+                rebaseRequired: true,
               }),
           }),
         ],
       });
       yield* service.summary(reference);
       const detail = yield* service.detail(reference);
       const summary = yield* service.summary(reference);
+      assert.strictEqual(detail.rebaseRequired, true);
+      assert.strictEqual(summary.rebaseRequired, true);
       assert.strictEqual(summary.isDraft, false);
       assert.deepStrictEqual(summary.author, detail.author);
       assert.strictEqual(summary.additions, 14);

apps/server/src/pullRequest/PullRequestService.ts

@@ -1309,6 +1309,9 @@ export const make = Effect.gen(function* () {
       state: input.item.state,
       isDraft: input.item.isDraft,
       mergeability: input.item.mergeability,
+      ...(input.item.rebaseRequired === undefined
+        ? {}
+        : { rebaseRequired: input.item.rebaseRequired }),
       additions: input.item.additions,
       deletions: input.item.deletions,
       createdAt: input.item.createdAt,
@@ -1792,6 +1795,9 @@ export const make = Effect.gen(function* () {
     ...(changeRequest.mergeability === undefined
       ? {}
       : { mergeability: changeRequest.mergeability }),
+    ...(changeRequest.rebaseRequired === undefined
+      ? {}
+      : { rebaseRequired: changeRequest.rebaseRequired }),
     ...(changeRequest.stack === undefined ? {} : { stack: changeRequest.stack }),
     ...(changeRequest.headSha?.trim() ? { headSha: changeRequest.headSha.trim() } : {}),
     ...(changeRequest.autoMergeEnabled === undefined
@@ -1891,6 +1897,9 @@ export const make = Effect.gen(function* () {
             state: changeRequest.state,
             isDraft: changeRequest.isDraft,
             mergeability: changeRequest.mergeability,
+            ...(changeRequest.rebaseRequired === undefined
+              ? {}
+              : { rebaseRequired: changeRequest.rebaseRequired }),
             additions: changeRequest.additions,
             deletions: changeRequest.deletions,
             changedFiles: changeRequest.changedFiles,
@@ -3330,6 +3339,7 @@ export const make = Effect.gen(function* () {
     deletions: detail.deletions,
     changedFiles: detail.changedFiles,
     mergeability: detail.mergeability,
+    ...(detail.rebaseRequired === undefined ? {} : { rebaseRequired: detail.rebaseRequired }),
     headBranch: detail.headBranch,
     baseBranch: detail.baseBranch,
     closedAt: detail.closedAt,

packages/contracts/src/pullRequest.ts

@@ -370,6 +370,7 @@ export const PullRequestListEntry = Schema.Struct({
   state: PullRequestState,
   isDraft: Schema.Boolean,
   mergeability: PullRequestMergeability,
+  rebaseRequired: Schema.optional(Schema.Boolean),
   /** Zero until fetched through `PullRequestListStatsInput`; GitHub listings omit counts. */
   additions: NonNegativeInt,
   deletions: NonNegativeInt,
@@ -528,6 +529,7 @@ export const PullRequestSummary = Schema.Struct({
   reviewDecision: Schema.optional(Schema.NullOr(PullRequestReviewDecision)),
   checksState: Schema.optional(Schema.NullOr(PullRequestChecksState)),
   mergeability: Schema.optional(PullRequestMergeability),
+  rebaseRequired: Schema.optional(Schema.Boolean),
   /** Null when the host says the pull request is in no stack; absent when the read did not ask. */
   stack: Schema.optional(Schema.NullOr(PullRequestStackMembership)),
   headSha: Schema.optional(TrimmedNonEmptyString),
@@ -651,6 +653,7 @@ export const PullRequestDetail = Schema.Struct({
   state: PullRequestState,
   isDraft: Schema.Boolean,
   mergeability: PullRequestMergeability,
+  rebaseRequired: Schema.optional(Schema.Boolean),
   additions: NonNegativeInt,
   deletions: NonNegativeInt,
   changedFiles: NonNegativeInt,

packages/contracts/src/threadPullRequest.ts

@@ -51,6 +51,7 @@ export const ThreadPullRequestSnapshot = Schema.Struct({
   reviewDecision: Schema.optional(Schema.NullOr(PullRequestReviewDecision)),
   checksState: Schema.optional(Schema.NullOr(PullRequestChecksState)),
   mergeability: Schema.optional(PullRequestMergeability),
+  rebaseRequired: Schema.optional(Schema.Boolean),
 });
 export type ThreadPullRequestSnapshot = typeof ThreadPullRequestSnapshot.Type;
 
@@ -97,6 +98,7 @@ export const ThreadPullRequestWatch = Schema.Struct({
   /** Reported remarks at remarksThrough, so late arrivals at that timestamp still count. */
   remarkIds: Schema.Array(TrimmedNonEmptyString),
   conflicting: Schema.Boolean,
+  rebaseRequired: Schema.optional(Schema.Boolean),
   /** Last removal seen; null after an empty read, absent before the first read. */
   mergeQueueRemovalId: Schema.optional(Schema.NullOr(TrimmedNonEmptyString)),
   /** Consecutive comment-only wakes; limited to prevent bot loops. */

packages/source-control-core/src/server/PullRequestProvider.ts

@@ -97,6 +97,7 @@ export interface ProviderChangeRequest {
   readonly state: PullRequestState;
   readonly isDraft: boolean;
   readonly mergeability: PullRequestMergeability;
+  readonly rebaseRequired?: boolean | undefined;
   readonly additions: number;
   readonly deletions: number;
   readonly createdAt: string;
@@ -127,6 +128,7 @@ export interface ProviderChangeRequestSummary {
   readonly reviewDecision?: PullRequestReviewDecision | null | undefined;
   readonly checksState?: PullRequestChecksState | null | undefined;
   readonly mergeability?: PullRequestMergeability | undefined;
+  readonly rebaseRequired?: boolean | undefined;
   /** Null means no stack; absent means not requested. */
   readonly stack?: PullRequestStackMembership | null | undefined;
   readonly headSha?: string | undefined;