feat(git): allow multiple PRs per task with an Other PRs submenu

A task now accumulates every PR created for it instead of keeping a
single overwritten pr_url. The first-created PR stays primary; the rest
appear in an "Other PRs" submenu on the PR badge dropdown showing each
PR's number, a generated short summary, lifecycle state, and repo (when
it differs). Clicking one promotes it to primary, optimistically so the
switch is instant.

Cloud TaskRun.output stays backwards and forwards compatible: writers
maintain pr_url === pr_urls[0] plus an additive pr_summaries dict, all
writes are fetch-merge-patch preserving foreign keys, and readers
reconcile old-client pr_url overwrites by appending them at the end.
Attach writes are serialized per session so concurrent PR creations
can't clobber each other, and findPrUrls now extracts every PR URL in
an output chunk rather than the first.

Local accumulation only trusts attributable detections (cloud
attribution, linked branch, dedicated worktree); PRs found on a shared
folder's current branch no longer leak into other tasks' lists, and a
data migration resets previously accumulated lists.

Generated-By: PostHog Code
Task-Id: 6a70b8ad-752c-451e-bdd6-a4bf178dfe38

Author: frankh

packages/agent/src/agent.ts

@@ -1,3 +1,4 @@
+import { buildPrOutput, mergePrUrls, readPrUrls } from "@posthog/shared";
 import {
   createAcpConnection,
   type InProcessAcpConnection,
@@ -167,8 +168,13 @@ export class Agent {
       throw error;
     }
 
+    const freshOutput = await this.posthogAPI
+      .getTaskRun(taskId, this.taskRunId)
+      .then((run) => run.output)
+      .catch(() => null);
+    const urls = mergePrUrls(readPrUrls(freshOutput), [prUrl]);
     const updates: TaskRunUpdate = {
-      output: { pr_url: prUrl },
+      output: buildPrOutput(freshOutput, urls),
     };
     if (branchName) {
       updates.branch = branchName;

packages/agent/src/pr-url-detector.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { findPrUrl, wasCreatedRecently } from "./pr-url-detector";
+import { findPrUrl, findPrUrls, wasCreatedRecently } from "./pr-url-detector";
 
 const PR_URL = "https://github.com/PostHog/posthog.com/pull/17764";
 
@@ -33,6 +33,25 @@ describe("findPrUrl", () => {
   });
 });
 
+describe("findPrUrls", () => {
+  const OTHER = "https://github.com/PostHog/posthog/pull/99";
+
+  it("finds every PR URL in one chunk, in order", () => {
+    expect(findPrUrls(`Opened ${PR_URL} and ${OTHER} today`)).toEqual([
+      PR_URL,
+      OTHER,
+    ]);
+  });
+
+  it("dedupes repeated mentions of the same PR", () => {
+    expect(findPrUrls(`${PR_URL} again: ${PR_URL}`)).toEqual([PR_URL]);
+  });
+
+  it("returns an empty array when there is no PR URL", () => {
+    expect(findPrUrls("nothing here")).toEqual([]);
+  });
+});
+
 describe("wasCreatedRecently", () => {
   const now = new Date("2026-06-18T17:00:00Z").getTime();
   const maxAge = 15 * 60 * 1000;

packages/agent/src/pr-url-detector.ts

@@ -1,11 +1,15 @@
-const PR_URL_REGEX = /https:\/\/github\.com\/[^/\s"]+\/[^/\s"]+\/pull\/\d+/;
+const PR_URL_REGEX = /https:\/\/github\.com\/[^/\s"]+\/[^/\s"]+\/pull\/\d+/g;
 
 // A fixed window (not "since run start") so a PR the agent merely views on a
 // long run is too old to be mistaken for one it just created.
 export const PR_CREATION_RECENCY_MS = 5 * 60 * 1000;
 
 export function findPrUrl(text: string): string | null {
-  return text.match(PR_URL_REGEX)?.[0] ?? null;
+  return findPrUrls(text)[0] ?? null;
+}
+
+export function findPrUrls(text: string): string[] {
+  return [...new Set(text.match(PR_URL_REGEX) ?? [])];
 }
 
 // Fails closed on missing/invalid input so we never attribute on uncertainty.

packages/agent/src/server/agent-server.test.ts

@@ -1865,7 +1865,10 @@ describe("AgentServer HTTP Mode", () => {
       ): void;
       fetchPrCreatedAt(url: string): Promise<string | null>;
       detectedPrUrl: string | null;
-      posthogAPI: { updateTaskRun: ReturnType<typeof vi.fn> };
+      posthogAPI: {
+        getTaskRun: ReturnType<typeof vi.fn>;
+        updateTaskRun: ReturnType<typeof vi.fn>;
+      };
     };
 
     const justNow = () => new Date().toISOString();
@@ -1874,7 +1877,20 @@ describe("AgentServer HTTP Mode", () => {
     const setup = (prCreatedAt: string | null): PrTestServer => {
       const s = createServer() as unknown as PrTestServer;
       s.fetchPrCreatedAt = vi.fn(async () => prCreatedAt);
-      s.posthogAPI = { updateTaskRun: vi.fn(async () => ({})) };
+      let storedOutput: Record<string, unknown> | null = null;
+      s.posthogAPI = {
+        getTaskRun: vi.fn(async () => ({ output: storedOutput })),
+        updateTaskRun: vi.fn(
+          async (
+            _taskId: string,
+            _runId: string,
+            updates: { output: Record<string, unknown> },
+          ) => {
+            storedOutput = updates.output;
+            return {};
+          },
+        ),
+      };
       return s;
     };
 
@@ -1885,7 +1901,7 @@ describe("AgentServer HTTP Mode", () => {
       s.maybeAttachCreatedPr(payload, terminalUpdate(PR_URL));
       await flush();
       expect(s.posthogAPI.updateTaskRun).toHaveBeenCalledWith("t", "r", {
-        output: { pr_url: PR_URL },
+        output: { pr_url: PR_URL, pr_urls: [PR_URL] },
       });
       expect(s.detectedPrUrl).toBe(PR_URL);
     });
@@ -1916,16 +1932,15 @@ describe("AgentServer HTTP Mode", () => {
       expect(s.posthogAPI.updateTaskRun).toHaveBeenCalledTimes(1);
     });
 
-    it("attributes the most recent PR when a run opens several, in detection order", async () => {
-      // output.pr_url holds one value; the latest PR the run created is the useful one.
+    it("accumulates every PR a run opens, keeping the first as primary", async () => {
       const s = setup(justNow());
       const second = "https://github.com/PostHog/posthog.com/pull/17765";
       s.maybeAttachCreatedPr(payload, terminalUpdate(PR_URL));
       s.maybeAttachCreatedPr(payload, terminalUpdate(second));
       await flush();
       expect(s.posthogAPI.updateTaskRun).toHaveBeenCalledTimes(2);
       expect(s.posthogAPI.updateTaskRun).toHaveBeenLastCalledWith("t", "r", {
-        output: { pr_url: second },
+        output: { pr_url: PR_URL, pr_urls: [PR_URL, second] },
       });
       expect(s.detectedPrUrl).toBe(second);
     });

packages/agent/src/server/agent-server.ts

@@ -16,6 +16,7 @@ import {
 import { type ServerType, serve } from "@hono/node-server";
 import { execGh } from "@posthog/git/gh";
 import { getCurrentBranch } from "@posthog/git/queries";
+import { buildPrOutput, mergePrUrls, readPrUrls } from "@posthog/shared";
 import { unzipSync } from "fflate";
 import { Hono } from "hono";
 import { z } from "zod";
@@ -44,7 +45,7 @@ import type { PermissionMode } from "../execution-mode";
 import { DEFAULT_CODEX_MODEL, fetchGatewayModels } from "../gateway-models";
 import { HandoffCheckpointTracker } from "../handoff-checkpoint";
 import { PostHogAPIClient } from "../posthog-api";
-import { findPrUrl, wasCreatedRecently } from "../pr-url-detector";
+import { findPrUrls, wasCreatedRecently } from "../pr-url-detector";
 import {
   formatConversationForResume,
   type ResumeState,
@@ -3351,13 +3352,14 @@ ${signedCommitInstructions}${prLinkInstructions}${shellEfficiencyInstructions}
     update: Record<string, unknown> | undefined,
   ): void {
     if (!update) return;
-    const prUrl = findPrUrl(JSON.stringify(update));
-    if (!prUrl || this.evaluatedPrUrls.has(prUrl)) return;
-    this.evaluatedPrUrls.add(prUrl);
-    // Chain so attributions run in detection order; later PRs overwrite earlier ones.
-    this.prAttributionChain = this.prAttributionChain
-      .catch(() => {})
-      .then(() => this.attachPrIfCreatedThisRun(payload, prUrl));
+    for (const prUrl of findPrUrls(JSON.stringify(update))) {
+      if (this.evaluatedPrUrls.has(prUrl)) continue;
+      this.evaluatedPrUrls.add(prUrl);
+      // Chain so attributions run in detection order; later PRs append after earlier ones.
+      this.prAttributionChain = this.prAttributionChain
+        .catch(() => {})
+        .then(() => this.attachPrIfCreatedThisRun(payload, prUrl));
+    }
   }
 
   private async attachPrIfCreatedThisRun(
@@ -3385,8 +3387,13 @@ ${signedCommitInstructions}${prLinkInstructions}${shellEfficiencyInstructions}
     this.detectedPrUrl = prUrl;
 
     try {
+      const freshOutput = await this.posthogAPI
+        .getTaskRun(payload.task_id, payload.run_id)
+        .then((run) => run.output)
+        .catch(() => null);
+      const urls = mergePrUrls(readPrUrls(freshOutput), [prUrl]);
       await this.posthogAPI.updateTaskRun(payload.task_id, payload.run_id, {
-        output: { pr_url: prUrl },
+        output: buildPrOutput(freshOutput, urls),
       });
       this.logger.debug("Attributed created PR to task run", {
         taskId: payload.task_id,

packages/core/src/git-interaction/gitInteractionService.test.ts

@@ -276,6 +276,7 @@ describe("GitInteractionService.runCreatePr", () => {
     expect(effects.attachPrUrlToTask).toHaveBeenCalledWith(
       "t",
       "https://example.test/pr/1",
+      undefined,
     );
     if (result.outcome === "success") {
       expect(result.linkedBranchName).toBe("feature-x");

packages/core/src/git-interaction/gitInteractionService.ts

@@ -82,7 +82,7 @@ export interface GitInteractionEffects {
   markFirstPrShipped(): void;
   celebrate(): void;
   openExternalUrl(url: string): void;
-  attachPrUrlToTask(taskId: string, prUrl: string): void;
+  attachPrUrlToTask(taskId: string, prUrl: string, prTitle?: string): void;
   getConversationContext(taskId: string): string | undefined;
   logError(message: string, error: unknown): void;
   logWarn(message: string, context: Record<string, unknown>): void;
@@ -385,7 +385,11 @@ export class GitInteractionService {
 
       if (result.prUrl) {
         this.effects.openExternalUrl(result.prUrl);
-        this.effects.attachPrUrlToTask(input.taskId, result.prUrl);
+        this.effects.attachPrUrlToTask(
+          input.taskId,
+          result.prUrl,
+          input.prTitle.trim() || undefined,
+        );
       }
 
       return {

packages/core/src/git-pr/git-pr.ts

@@ -233,6 +233,40 @@ ${truncatedDiff || "(no diff available)"}${contextSection}`;
     };
   }
 
+  async generatePrShortSummary(
+    conversationContext?: string,
+    prTitle?: string,
+  ): Promise<{ summary: string }> {
+    if (!conversationContext && !prTitle) return { summary: "" };
+
+    const system = `You generate ultra-short labels for pull requests. Given context about a PR, output a label of 15-20 characters that captures what the PR does.
+
+Rules:
+- 15-20 characters total, never more than 24
+- Plain words, no punctuation, no quotes, no trailing period
+- Imperative mood ("Fix login loop" not "Fixed login loop")
+- Output only the label, nothing else`;
+
+    const parts: string[] = [];
+    if (prTitle) parts.push(`PR title: ${prTitle}`);
+    if (conversationContext) {
+      parts.push(`Conversation context:\n${conversationContext}`);
+    }
+
+    const response = await this.llm.prompt(
+      [{ role: "user", content: parts.join("\n\n") }],
+      {
+        system,
+        maxTokens: 30,
+        model: HELPER_GATEWAY_MODEL,
+        posthogProperties: { $ai_span_name: "pr_short_summary" },
+      },
+    );
+
+    const summary = response.content.trim().replace(/^["']|["']$/g, "");
+    return { summary: summary.length > 24 ? summary.slice(0, 24) : summary };
+  }
+
   /**
    * Orchestrate branch -> commit -> push -> PR creation as a saga. Host git/gh
    * operations come through `host`; commit-message and PR-description generation

packages/core/src/git/router-schemas.ts

@@ -384,6 +384,7 @@ export const getPrDetailsByUrlOutput = z.object({
   merged: z.boolean(),
   draft: z.boolean(),
   headRefName: z.string().nullable(),
+  title: z.string().nullable(),
 });
 export type PrDetailsByUrlOutput = z.infer<typeof getPrDetailsByUrlOutput>;
 
@@ -496,6 +497,15 @@ export const generatePrTitleAndBodyOutput = z.object({
   body: z.string(),
 });
 
+export const generatePrShortSummaryInput = z.object({
+  conversationContext: z.string().optional(),
+  prTitle: z.string().optional(),
+});
+
+export const generatePrShortSummaryOutput = z.object({
+  summary: z.string(),
+});
+
 export const gitStateSnapshotSchema = z.object({
   changedFiles: z.array(changedFileSchema).optional(),
   diffStats: diffStatsSchema.optional(),

packages/core/src/sidebar/buildSidebarData.ts

@@ -1,3 +1,4 @@
+import { readPrUrls } from "@posthog/shared";
 import type { Task, TaskRunStatus } from "@posthog/shared/domain-types";
 import { getRepositoryInfo } from "./groupTasks";
 import type { TaskData } from "./sidebarData.types";
@@ -150,9 +151,9 @@ export function deriveTaskData(
     taskLastViewedAt != null && lastActivityAt > taskLastViewedAt;
 
   const cloudPrUrl =
-    typeof task.latest_run?.output?.pr_url === "string"
-      ? task.latest_run.output.pr_url
-      : ((session?.cloudOutput?.pr_url as string | undefined) ?? null);
+    readPrUrls(task.latest_run?.output)[0] ??
+    readPrUrls(session?.cloudOutput)[0] ??
+    null;
 
   const originProduct =
     task.origin_product ??