feat(prs): navigate, merge and rebase GitHub stacks

apps/mobile/src/features/threads/thread-work-log.tsx

@@ -76,7 +76,7 @@ export const THREAD_DISCLOSURE_TRANSITION_MS = 180;
 const WORK_LOG_LAYOUT_TRANSITION = LinearTransition.duration(THREAD_DISCLOSURE_TRANSITION_MS);
 const WORK_LOG_DETAIL_ENTER_TRANSITION = FadeIn.duration(140);
 const WORK_LOG_DETAIL_EXIT_TRANSITION = FadeOut.duration(120);
-type WorkContentIcon = AppSymbolName | "browser" | "t3-code";
+type WorkContentIcon = AppSymbolName | "browser" | "t3-code" | "pull-request";
 
 function WorkLogIcon(props: {
   readonly icon: WorkContentIcon;
@@ -92,7 +92,13 @@ function WorkLogIcon(props: {
   }
   return (
     <SymbolView
-      name={props.icon === "browser" ? { ios: "globe", android: "public" } : props.icon}
+      name={
+        props.icon === "pull-request"
+          ? "arrow.triangle.pull"
+          : props.icon === "browser"
+            ? { ios: "globe", android: "public" }
+            : props.icon
+      }
       size={14}
       weight="medium"
       {...(colorClassName ? { tintColorClassName: colorClassName } : { tintColor: props.color })}
@@ -893,7 +899,7 @@ export function ThreadWorkGroupToggle(props: {
   readonly iconSubtleColor: import("react-native").ColorValue;
   readonly summary: string;
   readonly summaryKind: ToolGroupSummaryKind;
-  readonly summaryToolIcon?: "browser" | "t3-code";
+  readonly summaryToolIcon?: "browser" | "t3-code" | "pull-request";
   readonly themeAppearance: "light" | "dark";
   readonly toolSurface?: import("@t3tools/contracts").ToolActivitySurface;
   readonly toolIcon?: ToolActivityIcon;
@@ -1231,6 +1237,11 @@ function ToolActivityImage(props: {
 
 function toolGroupSummarySymbolName(kind: ToolGroupSummaryKind): AppSymbolName {
   switch (kind) {
+    case "pull-request":
+    case "link-pr":
+    case "unlink-pr":
+    case "list-prs":
+      return "arrow.triangle.pull";
     case "read":
       return { ios: "eye", android: "visibility" };
     case "edit":

apps/mobile/src/lib/threadActivity.ts

@@ -167,7 +167,7 @@ export type ThreadFeedEntry =
       readonly summaryKind: ToolGroupSummaryKind;
       readonly toolSurface?: WorkLogEntry["toolSurface"];
       readonly toolIcon?: WorkLogEntry["toolIcon"];
-      readonly summaryToolIcon?: "browser" | "t3-code";
+      readonly summaryToolIcon?: "browser" | "t3-code" | "pull-request";
       readonly hasFailure: boolean;
       readonly live: boolean;
       readonly shimmer: boolean;

apps/server/src/environment/ServerEnvironment.ts

@@ -231,6 +231,7 @@ export const make = Effect.gen(function* () {
       threadActiveReorder: true,
       threadTitleRegeneration: true,
       threadPullRequests: true,
+      pullRequestStackActions: true,
       threadPullRequestLinking: true,
       environmentIcon: true,
       ...(serverSelfUpdate === null ? {} : { serverSelfUpdate }),

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

@@ -178,8 +178,9 @@ const makeHarness = Effect.fn("makePullRequestSyncHarness")(function* (options:
       return yield* options.summary?.(input) ?? Effect.succeed(makeSummary(input));
     });
 
-  const stack: PullRequestService["Service"]["stack"] = (input) =>
+  const stack: PullRequestService["Service"]["stack"] = (input, readOptions) =>
     Effect.gen(function* () {
+      assert.strictEqual(readOptions?.includeDetails, false);
       yield* Ref.update(stackCalls, (calls) => [...calls, input]);
       return yield* options.stack?.(input) ?? Effect.succeed(null);
     });

apps/server/src/orchestration/PullRequestSyncReactor.ts

@@ -256,7 +256,7 @@ export const make = Effect.gen(function* () {
             entry.link.snapshot === null || !snapshotFieldsEqual(entry.link.snapshot, fields),
         );
       const fetchedStack = needsStack
-        ? yield* pullRequests.stack(ref).pipe(
+        ? yield* pullRequests.stack(ref, { includeDetails: false }).pipe(
             Effect.map((stack) => ({
               stack: stack === null ? null : ({ kind: "native", ...stack } as const),
             })),

apps/server/src/orchestration/ThreadPullRequestReactor.test.ts

@@ -1,9 +1,11 @@
 import {
+  CheckpointRef,
   EventId,
   GitManagerError,
   ProjectId,
   ProviderInstanceId,
   ThreadId,
+  TurnId,
   type OrchestrationCommand,
   type OrchestrationEvent,
   type OrchestrationProjectShell,
@@ -311,54 +313,79 @@ describe("ThreadPullRequestReactor", () => {
     ),
   );
 
-  it.effect("refreshes discovery after a turn ends without client demand", () =>
-    Effect.scoped(
-      Effect.gen(function* () {
-        const current = thread("turn-thread");
-        const detected = yield* Ref.make<GitBranchPullRequest | null>(null);
-        const fixture = yield* makeHarness({
-          threads: [current],
-          branchPullRequest: (_input, options) =>
-            options?.refresh
-              ? Ref.set(detected, branchPullRequest()).pipe(Effect.andThen(Ref.get(detected)))
-              : Ref.get(detected),
-        });
-        yield* Effect.gen(function* () {
-          const reactor = yield* fixture.start();
-          expect(yield* Ref.get(fixture.commands)).toHaveLength(0);
-          yield* fixture.publish({
-            type: "thread.session-set",
-            sequence: 2,
-            eventId: EventId.make("turn-finished"),
-            aggregateKind: "thread",
-            aggregateId: current.id,
-            occurredAt: NOW,
-            commandId: null,
-            causationEventId: null,
-            correlationId: null,
-            metadata: {},
-            payload: {
-              threadId: current.id,
-              session: {
+  it.effect.each(["session-first", "checkpoint-first"] as const)(
+    "refreshes discovery once after a turn ends with %s event ordering",
+    (order) =>
+      Effect.scoped(
+        Effect.gen(function* () {
+          const current = thread("turn-thread");
+          const detected = yield* Ref.make<GitBranchPullRequest | null>(null);
+          const fixture = yield* makeHarness({
+            threads: [current],
+            branchPullRequest: (_input, options) =>
+              options?.refresh
+                ? Ref.set(detected, branchPullRequest()).pipe(Effect.andThen(Ref.get(detected)))
+                : Ref.get(detected),
+          });
+          yield* Effect.gen(function* () {
+            const reactor = yield* fixture.start();
+            expect(yield* Ref.get(fixture.commands)).toHaveLength(0);
+            const sessionEvent: OrchestrationEvent = {
+              type: "thread.session-set",
+              sequence: 2,
+              eventId: EventId.make("turn-finished"),
+              aggregateKind: "thread",
+              aggregateId: current.id,
+              occurredAt: NOW,
+              commandId: null,
+              causationEventId: null,
+              correlationId: null,
+              metadata: {},
+              payload: {
                 threadId: current.id,
+                session: {
+                  threadId: current.id,
+                  status: "ready",
+                  providerName: "Codex",
+                  runtimeMode: "full-access",
+                  activeTurnId: null,
+                  lastError: null,
+                  updatedAt: NOW,
+                },
+              },
+            };
+            const checkpointEvent: OrchestrationEvent = {
+              ...sessionEvent,
+              type: "thread.turn-diff-completed",
+              sequence: 3,
+              eventId: EventId.make("checkpoint-finished"),
+              payload: {
+                threadId: current.id,
+                turnId: TurnId.make("turn"),
+                checkpointTurnCount: 1,
+                checkpointRef: CheckpointRef.make("checkpoint"),
                 status: "ready",
-                providerName: "Codex",
-                runtimeMode: "full-access",
-                activeTurnId: null,
-                lastError: null,
-                updatedAt: NOW,
+                files: [],
+                assistantMessageId: null,
+                completedAt: NOW,
               },
-            },
-          });
-          yield* Queue.take(fixture.reads);
-          yield* reactor.drain;
-          expect((yield* Ref.get(fixture.commands))[0]?.branchPullRequest).toEqual(reference(42));
-          expect((yield* Ref.get(fixture.branchCalls)).filter((call) => call.refresh)).toHaveLength(
-            1,
-          );
-        }).pipe(Effect.provide(fixture.layer));
-      }),
-    ),
+            };
+            const events =
+              order === "session-first"
+                ? [sessionEvent, checkpointEvent]
+                : [checkpointEvent, sessionEvent];
+            for (const event of events) {
+              yield* fixture.publish(event);
+              yield* Queue.take(fixture.reads);
+              yield* reactor.drain;
+            }
+            expect((yield* Ref.get(fixture.commands))[0]?.branchPullRequest).toEqual(reference(42));
+            expect(
+              (yield* Ref.get(fixture.branchCalls)).filter((call) => call.refresh),
+            ).toHaveLength(1);
+          }).pipe(Effect.provide(fixture.layer));
+        }),
+      ),
   );
 
   it.effect("uses live worktrees and falls back to the project for removed worktrees", () =>
@@ -455,54 +482,56 @@ describe("ThreadPullRequestReactor", () => {
     ),
   );
 
-  it.effect("retries failed settled backfills and stops querying them after success", () =>
-    Effect.scoped(
-      Effect.gen(function* () {
-        const online = yield* Ref.make(false);
-        const fixture = yield* makeHarness({
-          threads: [
-            thread("backfill", { settledOverride: "settled", settledAt: NOW }),
-            thread("known", {
-              branch: "known",
-              settledOverride: "settled",
-              settledAt: NOW,
-              branchPullRequest: reference(1),
-            }),
-          ],
-          branchPullRequest: ({ cwd }) =>
-            Ref.get(online).pipe(
-              Effect.flatMap((connected) =>
-                connected
-                  ? Effect.succeed(branchPullRequest(42, "merged"))
-                  : Effect.fail(
-                      new GitManagerError({
-                        operation: "branchPullRequest",
-                        cwd,
-                        detail: "Offline",
-                      }),
-                    ),
+  it.effect.each(["settled", null] as const)(
+    "retries settled backfills and stops after success with settledOverride %s",
+    (settledOverride) =>
+      Effect.scoped(
+        Effect.gen(function* () {
+          const online = yield* Ref.make(false);
+          const fixture = yield* makeHarness({
+            threads: [
+              thread("backfill", { settledOverride, settledAt: NOW }),
+              thread("known", {
+                branch: "known",
+                settledOverride,
+                settledAt: NOW,
+                branchPullRequest: reference(1),
+              }),
+            ],
+            branchPullRequest: ({ cwd }) =>
+              Ref.get(online).pipe(
+                Effect.flatMap((connected) =>
+                  connected
+                    ? Effect.succeed(branchPullRequest(42, "merged"))
+                    : Effect.fail(
+                        new GitManagerError({
+                          operation: "branchPullRequest",
+                          cwd,
+                          detail: "Offline",
+                        }),
+                      ),
+                ),
               ),
-            ),
-        });
-        yield* Effect.gen(function* () {
-          const reactor = yield* fixture.start();
-          expect(yield* Ref.get(fixture.commands)).toHaveLength(0);
-          yield* Ref.set(online, true);
-          yield* TestClock.adjust("1 minute");
-          yield* Queue.take(fixture.reads);
-          yield* reactor.drain;
-          expect((yield* Ref.get(fixture.commands))[0]?.threadId).toBe("backfill");
-          yield* TestClock.adjust("1 minute");
-          yield* Queue.take(fixture.reads);
-          yield* reactor.drain;
-          expect((yield* Ref.get(fixture.branchCalls)).map((call) => call.branch)).toEqual([
-            "feature",
-            "feature",
-            "feature",
-          ]);
-        }).pipe(Effect.provide(fixture.layer));
-      }),
-    ),
+          });
+          yield* Effect.gen(function* () {
+            const reactor = yield* fixture.start();
+            expect(yield* Ref.get(fixture.commands)).toHaveLength(0);
+            yield* Ref.set(online, true);
+            yield* TestClock.adjust("1 minute");
+            yield* Queue.take(fixture.reads);
+            yield* reactor.drain;
+            expect((yield* Ref.get(fixture.commands))[0]?.threadId).toBe("backfill");
+            yield* TestClock.adjust("1 minute");
+            yield* Queue.take(fixture.reads);
+            yield* reactor.drain;
+            expect((yield* Ref.get(fixture.branchCalls)).map((call) => call.branch)).toEqual([
+              "feature",
+              "feature",
+              "feature",
+            ]);
+          }).pipe(Effect.provide(fixture.layer));
+        }),
+      ),
   );
 
   it.effect("stops retrying a settled backfill after repeated lookup failures", () =>

apps/server/src/orchestration/ThreadPullRequestReactor.ts

@@ -101,7 +101,10 @@ export const make = Effect.gen(function* () {
     const projects = new Map(snapshot.projects.map((project) => [project.id, project]));
     if (request.backfill) {
       for (const thread of snapshot.threads) {
-        if (thread.settledOverride === "settled" && thread.branchPullRequest == null) {
+        if (
+          (thread.settledOverride === "settled" || thread.settledAt !== null) &&
+          thread.branchPullRequest == null
+        ) {
           pendingBackfill.set(thread.id, BACKFILL_ATTEMPTS);
         }
       }
@@ -114,7 +117,7 @@ export const make = Effect.gen(function* () {
       (thread) =>
         thread.archivedAt === null &&
         (request.threadId === null || thread.id === request.threadId) &&
-        (thread.settledOverride !== "settled" ||
+        ((thread.settledOverride !== "settled" && thread.settledAt === null) ||
           request.threadId !== null ||
           pendingBackfill.has(thread.id)) &&
         (thread.branch !== null || thread.branchPullRequest != null),
@@ -327,7 +330,9 @@ export const make = Effect.gen(function* () {
           event.payload.session.status !== "running" &&
           event.payload.session.status !== "starting"
         ) {
-          return worker.enqueue({ threadId: event.payload.threadId, refresh: true });
+          // Checkpoint completion forces the post-turn read. Session lifecycle
+          // events reuse it regardless of which event reaches this worker first.
+          return worker.enqueue({ threadId: event.payload.threadId, refresh: false });
         }
         break;
       case "thread.turn-diff-completed":