paseo-follow-up 0.2.0 → 0.3.0

package/OVERVIEW.md

@@ -2,7 +2,7 @@
 
 Follow-up keeps PR stacks, remaining tasks and explicit agent completion attached to a Paseo workspace. It groups workspaces by whether you or an agent can act next and retains settled PR history.
 
-Requires Paseo 0.14+, Node 22+ and authenticated gh on the daemon host. Graphite CLI authentication is used for readiness and explicit Merge. The optional Send to Paseo browser companion enables Graphite's Merge when ready setting; it is not needed for tracking, recovery or follow-up.
+Requires Paseo 0.14+, Node 22+ and authenticated gh on the daemon host. Graphite CLI authentication is used for readiness and explicit Merge. The optional Send to Paseo browser companion enables Graphite's Merge when ready setting after separate machine/repository consent in Chrome; it is not needed for tracking, recovery or follow-up.
 
 Open the sidebar or Command-K, then Track this workspace. Project settings can enroll existing and new workspaces with original main-agent ownership; Auto always starts off. The retained development default enables canonical Git repositories named hero-poc, while other projects require opt-in. Disable that project default to stop further enrollment without losing records.
 
@@ -12,4 +12,4 @@ Repair batches go to the original main agent after a click, or after explicit pe
 
 This trusted unsandboxed plugin reads selected workspace metadata, saved agent history/configuration, GitHub status and existing CLI authentication. State and private recovery evidence remain in plugin-data/follow-through. Scoped MCP registration and reversible provider hooks support tracked main agents; Codex's trust review remains in force. Prompts and repair context are sent to your configured agent/provider. Site-specific reviewer and Cloud Run adapters only apply to the configured repository; unsupported deployments remain unknown.
 
-Merge, Merge when ready and reviewer requests require explicit developer controls. Auto and agent tools cannot authorize them. Follow-up has no Slack posting identity or background channel scanner. Stakeholder replies require the developer's authorization, original destination and a verified sent-message receipt from the agent.
+Merge, Merge when ready and reviewer requests require explicit developer controls. Optional direct browser grants trust that machine to change the PR toggle for the allowed repository, including later pushes; read-only grants require confirmation in Chrome. Auto and agent tools cannot authorize them. Follow-up has no Slack posting identity or background channel scanner. Stakeholder replies require the developer's authorization, original destination and a verified sent-message receipt from the agent.

package/README.md

@@ -40,6 +40,22 @@ Tasks default to manual. Explicit Now, After merge or After deploy triggers can
 
 ![Follow-up overview with sample workspaces](docs/screenshots/follow-up-overview.png)
 
+## Send to Paseo and Graphite
+
+With Send to Paseo installed on the same daemon, its composer can return to the agent that
+registered a PR here. New registrations record that agent; older records retain the workspace’s
+main agent. You can still choose a fresh agent in Send to Paseo. Tracking and follow-up remain
+usable without the companion.
+
+To control Graphite’s **Merge when ready** here, install the Send to Paseo plugin and Chrome
+extension, pair them, and keep Graphite open in Chrome. In extension settings → **Graphite browser
+access**, find this machine and allow an exact repository. Check **Allow Follow Up to change Merge
+when ready directly** to use this plugin’s toggle without another Chrome prompt. Leave it unchecked
+to confirm each change in Chrome. Revoke access in those settings at any time.
+
+This is a PR setting, including later pushes. Send pairing alone grants no Graphite access.
+See the [integration and security contract](https://github.com/tomgrin10/send-to-paseo/blob/main/docs/follow-up-integration.md).
+
 ## Data and permissions
 
 This is a trusted, unsandboxed plugin. It reads selected workspace metadata, agent history/configuration and GitHub PR status using your existing host credentials. Local state and private recovery evidence live under `$PASEO_HOME/plugin-data/follow-through`; credentials and provider configuration are not published or transferred.

package/client/panel.tsx

@@ -55,7 +55,7 @@ export function WorkspaceView({ theme, layout, workspace, navigation, loadError
     <View style={{ flexDirection: "row", alignItems: "center", gap: 8 }}><Text style={{ color: theme.colors.foreground, fontSize: 18, fontWeight: "600", flex: 1 }}>Follow-up</Text><Pressable accessibilityRole="switch" aria-checked={workspace.enable_auto_sends} accessibilityLabel="Auto" accessibilityHint="Allow automatic sends in this workspace" accessibilityState={{ checked: workspace.enable_auto_sends, disabled: change.isPending }} disabled={change.isPending} onPress={() => change.mutate({ workspaceId: workspace.id, enable_auto_sends: !workspace.enable_auto_sends })} style={{ minHeight: compact ? 44 : 36, paddingHorizontal: 10, borderRadius: 6, borderWidth: 1, borderColor: workspace.enable_auto_sends ? theme.colors.accent : theme.colors.border, backgroundColor: workspace.enable_auto_sends ? theme.colors.accent : theme.colors.surface0, flexDirection: "row", alignItems: "center", gap: 5, opacity: change.isPending ? 0.5 : 1 }}><Icon name={workspace.enable_auto_sends ? "Check" : "Circle"} size={13} color={workspace.enable_auto_sends ? theme.colors.accentForeground : theme.colors.foregroundMuted} /><Text style={{ fontSize: 13, color: workspace.enable_auto_sends ? theme.colors.accentForeground : theme.colors.foreground }}>Auto</Text></Pressable><Button title={update.isPending ? "Refreshing…" : "Refresh"} icon="RefreshCw" theme={theme} compact={compact} disabled={update.isPending} onPress={() => update.mutate()} /></View>
     <View style={{ marginTop: 8, gap: 6 }}><StatusLabel workspace={workspace} theme={theme} />{(state.status === "needs-you" || state.status === "done") && <Text style={{ color: theme.colors.foregroundMuted, fontSize: 12, lineHeight: 18 }}>{state.reason}</Text>}{workspace.hold && <Button title="Resume follow-up" theme={theme} compact={compact} onPress={() => change.mutate({ workspaceId: workspace.id, clearHold: true })} disabled={change.isPending} />}</View>
     {error && <Text accessibilityRole="alert" style={{ color: theme.colors.statusDanger, fontSize: 12, marginTop: 8 }}>{error}</Text>}
-    <Section title="Pull requests" count={workspace.prs.length} theme={theme} compact={compact}>{workspace.prs.length === 0 && <Text style={labelStyle}>No PRs recorded.</Text>}{workspace.prActions.filter(a => ["sending", "uncertain"].includes(a.state)).map(a => <View key={a.id} style={{ gap: 7 }}><Text style={{ ...labelStyle, color: theme.colors.statusWarning, lineHeight: 18 }}>{a.result}</Text>{a.state === "uncertain" && <Button title={inspectAction.isPending ? "Checking…" : "Check state"} theme={theme} compact={compact} disabled={inspectAction.isPending} onPress={() => inspectAction.mutate(a.id)} />}</View>)}{inspectAction.error && <Text accessibilityRole="alert" style={{ ...labelStyle, color: theme.colors.statusDanger }}>{inspectAction.error.message}</Text>}{activeStacks.map(stack => <StackGroup browserReady={browser.data?.ready ?? false} key={stack.name} name={stack.name} prs={stack.prs} workspace={workspace} theme={theme} onOpen={open} compact={compact} />)}{settledStacks.length > 0 && <Section title="Settled" count={settledStacks.reduce((count, stack) => count + stack.prs.length, 0)} theme={theme} compact={compact} initiallyExpanded={false}>{settledStacks.map(stack => <StackGroup browserReady={browser.data?.ready ?? false} key={stack.name} name={stack.name} prs={stack.prs} workspace={workspace} theme={theme} onOpen={open} compact={compact} />)}</Section>}{activeStacks.length > 0 && browser.data && !browser.data.ready && <Section title="Optional merge when ready" theme={theme} compact={compact} initiallyExpanded={false}><Text style={[labelStyle, { lineHeight: 18 }]}>Connect Chrome for Graphite’s When ready toggle.</Text><Text style={[labelStyle, { lineHeight: 18 }]}>Requires the paired Send to Paseo extension and an open Graphite tab.</Text><Button title="Connect Graphite" theme={theme} compact={compact} onPress={() => open("https://app.graphite.com")} /></Section>}</Section>
+    <Section title="Pull requests" count={workspace.prs.length} theme={theme} compact={compact}>{workspace.prs.length === 0 && <Text style={labelStyle}>No PRs recorded.</Text>}{workspace.prActions.filter(a => ["sending", "uncertain"].includes(a.state)).map(a => <View key={a.id} style={{ gap: 7 }}><Text style={{ ...labelStyle, color: theme.colors.statusWarning, lineHeight: 18 }}>{a.result}</Text>{a.state === "uncertain" && <Button title={inspectAction.isPending ? "Checking…" : "Check state"} theme={theme} compact={compact} disabled={inspectAction.isPending} onPress={() => inspectAction.mutate(a.id)} />}</View>)}{inspectAction.error && <Text accessibilityRole="alert" style={{ ...labelStyle, color: theme.colors.statusDanger }}>{inspectAction.error.message}</Text>}{activeStacks.map(stack => <StackGroup browserReady={browser.data?.ready ?? false} key={stack.name} name={stack.name} prs={stack.prs} workspace={workspace} theme={theme} onOpen={open} compact={compact} />)}{settledStacks.length > 0 && <Section title="Settled" count={settledStacks.reduce((count, stack) => count + stack.prs.length, 0)} theme={theme} compact={compact} initiallyExpanded={false}>{settledStacks.map(stack => <StackGroup browserReady={browser.data?.ready ?? false} key={stack.name} name={stack.name} prs={stack.prs} workspace={workspace} theme={theme} onOpen={open} compact={compact} />)}</Section>}{activeStacks.length > 0 && browser.data && !browser.data.ready && <Section title="Optional merge when ready" theme={theme} compact={compact} initiallyExpanded={false}><Text style={[labelStyle, { lineHeight: 18 }]}>Connect Chrome for Graphite’s When ready toggle.</Text><Text style={[labelStyle, { lineHeight: 18 }]}>Open Graphite in Chrome, then allow this machine and repository in Send to Paseo extension settings. Each toggle also needs confirmation in Chrome.</Text><Button title="Connect Graphite" theme={theme} compact={compact} onPress={() => open("https://app.graphite.com")} /></Section>}</Section>
     <Section title="Tasks" count={outstanding.length} theme={theme} compact={compact}>
       {!outstanding.length && <Text style={labelStyle}>No follow-through tasks.</Text>}
       {outstanding.map(o => <FollowTask key={o.id} obligation={o} workspace={workspace} theme={theme} compact={compact} />)}

package/client/pr-controls.tsx

@@ -3,7 +3,7 @@ import { Pressable, Text, View } from "react-native";
 import { useRpc } from "@getpaseo/plugin/client";
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import { confirmPrActionRpc, preparePrActionRpc, prControlStatusRpc, requestReviewersRpc } from "../shared/contracts";
-import type { ActionPlan, PrActionKind } from "../shared/pr-actions";
+import { prActionBlocks, type ActionPlan, type PrActionKind } from "../shared/pr-actions";
 import type { Pr, Workspace } from "../shared/model";
 import { Button, type Theme } from "./components";
 import { defaultReviewers, noReviewers } from "../shared/reviewers";
@@ -21,7 +21,7 @@ export function PrControls({ pr, workspace, theme, compact, browserReady }: { br
     if (result.kind !== "merge" && result.prs.length === 1 && !result.blockers.length && !result.prs[0].blockers.length) submit.mutate({ planId: result.id, scope: "target" });
     else setPlan(result);
   } });
-  const pendingAction = workspace.prActions.some(a => ["sending", "uncertain"].includes(a.state));
+  const pendingAction = workspace.prActions.some(a => prActionBlocks(a, [pr.key]));
   const busy = checking.isPending || submit.isPending;
   const actual = browserReady ? status.data?.pr : null;
   const known = !!actual && !status.error && !status.data?.error;

package/index.server.ts

@@ -4,6 +4,7 @@ import { mkdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { randomUUID } from "node:crypto";
 import * as rpc from "./shared/contracts";
+import { prOwner } from "./server/pr-owner";
 import { type Workspace } from "./shared/model";
 import { Store } from "./server/store";
 import { Engine, agentWorkspace, findWorkspace, interruptionHold } from "./server/engine";
@@ -93,6 +94,14 @@ export default function contribute(server: PluginServerContext) {
     void engine.tick();
     return { projects: await gateway.projects(await store.snapshot()) };
   });
+  server.handle(rpc.prOwnerRpc, async ({ repo, number }, { paseo }) => {
+    await requireReady();
+    const owner = prOwner(await store.snapshot(), repo, number);
+    if (!owner) return { owner: null };
+    const agent = (await paseo.agents.ref(owner.agentId).refresh())?.agent;
+    if (!agent || agent.archivedAt || agent.workspaceId !== owner.workspaceId) return { owner: null };
+    return { owner };
+  });
   server.handle(rpc.listRpc, async () => { await ready; return { workspaces: (await store.snapshot()).workspaces.filter(w => w.enable_tracking), error: loadError ?? hookError ?? engine.error }; });
   server.handle(rpc.getRpc, async ({ workspaceId }) => { await ready; return { workspace: (await store.snapshot()).workspaces.find(w => w.id === workspaceId && w.enable_tracking) ?? null, error: loadError ?? hookError ?? engine.error }; });
   server.handle(rpc.syncWorkspaceRpc, async ({ agentId, summary }, { paseo }) => {
@@ -145,8 +154,8 @@ export default function contribute(server: PluginServerContext) {
         seen.add(ancestor); ancestor = w.prs.find(p => p.key === ancestor)?.parent ?? null;
       }
       const altered = !existing || existing.stack !== stack || existing.parent !== parent || disposition !== undefined && existing.disposition !== disposition;
-      if (existing) { existing.stack = stack; existing.parent = parent; if (disposition !== undefined) existing.disposition = disposition; }
-      else w.prs.push({ key, repo, number, stack, parent, disposition: disposition ?? null, snapshot: null, error: null });
+      if (existing) { existing.registeredAgentId = agentId; existing.stack = stack; existing.parent = parent; if (disposition !== undefined) existing.disposition = disposition; }
+      else w.prs.push({ registeredAgentId: agentId, key, repo, number, stack, parent, disposition: disposition ?? null, snapshot: null, error: null });
       if (altered) changed(w); return w;
     });
     void engine.tick(); return result;
@@ -235,7 +244,7 @@ export default function contribute(server: PluginServerContext) {
     void engine.tick(); return result;
   });
   server.handle(rpc.browserStatusRpc, async () => { await requireReady(); return browser.status(); });
-  server.handle(rpc.browserExchangeRpc, async ({ clientId, ready: browserReady, acceptJobs, results }) => { await requireReady(); return { jobs: browser.exchange(clientId, browserReady, results, acceptJobs), accepted: results.map(r => r.id) }; });
+  server.handle(rpc.browserExchangeRpc, async ({ clientId, ready: browserReady, acceptJobs, results, repositories }) => { await requireReady(); return browser.exchange(clientId, browserReady, results, acceptJobs, repositories); });
   server.handle(rpc.prControlStatusRpc, async ({ workspaceId, prKey }) => { await requireReady(); return actions.status(workspaceId, prKey); });
   server.handle(rpc.preparePrActionRpc, async ({ workspaceId, prKey, kind }) => { await requireReady(); return actions.prepare(workspaceId, prKey, kind); });
   server.handle(rpc.confirmPrActionRpc, async ({ planId, scope }) => { await requireReady(); const result = await actions.confirm(planId, scope); void engine.tick(); return result; });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "paseo-follow-up",
   "private": false,
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Track workspace pull requests, queue follow-up work, and verify completion in Paseo.",
   "type": "module",
   "files": [

package/server/browser-bridge.ts

@@ -3,46 +3,59 @@ import { browserCommandSchema, type BrowserCommand, type BrowserPr, type Browser
 
 type Pending = { command: BrowserCommand; clientId: string | null; timer: ReturnType<typeof setTimeout>; resolve: (r: BrowserResult) => void };
 export class BrowserBridge {
-  private clients = new Map<string, { at: number; ready: boolean }>();
+  private clients = new Map<string, { at: number; ready: boolean; repositories: string[] }>();
   private pending = new Map<string, Pending>();
   private observations = new Map<string, { at: number; pr: BrowserPr }>();
-  status() {
-    const ready = [...this.clients.values()].some(c => c.ready && Date.now() - c.at < 15_000);
-    return { ready, reason: ready ? null : "Open Graphite in Chrome with the updated Send to Paseo extension to connect merge controls." };
+  status(repo?: string) {
+    const ready = [...this.clients.values()].some(c => c.ready && c.repositories.length > 0 && (!repo || c.repositories.includes(repo.toLowerCase())) && Date.now() - c.at < 15_000);
+    return { ready, reason: ready ? null : "Open Graphite in Chrome and grant this machine access to the repository in Send to Paseo settings." };
   }
   cached(repo: string, number: number, head: string): BrowserPr | null {
     const saved = this.observations.get(`${repo}#${number}`);
     return saved && Date.now() - saved.at < 15_000 && saved.pr.head === head ? saved.pr : null;
   }
-  exchange(clientId: string, ready: boolean, results: BrowserResult[], acceptJobs = true): BrowserCommand[] {
-    this.clients.set(clientId, { at: Date.now(), ready });
+  exchange(clientId: string, ready: boolean, results: BrowserResult[], acceptJobs = true, repositories: string[] = []): { jobs: BrowserCommand[]; accepted: string[] } {
+    const accepted: string[] = [];
+    for (const [id, client] of this.clients) if (Date.now() - client.at > 60_000) this.clients.delete(id);
+    if (!this.clients.has(clientId) && this.clients.size >= 100) return { jobs: [], accepted };
+    const scopes = repositories.map(r => r.toLowerCase());
+    this.clients.set(clientId, { at: Date.now(), ready, repositories: scopes });
     for (const result of results) {
       const job = this.pending.get(result.id);
-      if (!job || job.clientId !== clientId || job.command.nonce !== result.nonce) continue;
+      if (!job || job.clientId !== clientId || job.command.nonce !== result.nonce || Date.parse(job.command.expiresAt) <= Date.now()) continue;
+      if (!scopes.includes(job.command.repo.toLowerCase()) && !(result.outcome === "failed" && !result.prs.length && !result.applied.length)) continue;
+      if (new Set(result.prs.map(p => p.number)).size !== result.prs.length || new Set(result.applied).size !== result.applied.length) continue;
+      if (result.outcome === "completed" && (result.prs.length !== job.command.prs.length || result.prs.some(p => {
+        const target = job.command.prs.find(t => t.number === p.number);
+        return !target || p.head !== target.head || job.command.op !== "read" && (p.state !== "OPEN" || p.mergeWhenReady !== (job.command.op === "enable_mwr"));
+      }) || job.command.op !== "read" && result.applied.length !== job.command.prs.length)) continue;
       if (result.prs.some(p => p.repo !== job.command.repo || !job.command.prs.some(t => t.number === p.number))) continue;
       if (result.applied.some(n => !job.command.prs.some(p => p.number === n))) continue;
       clearTimeout(job.timer); this.pending.delete(result.id);
       for (const pr of result.prs) this.observations.set(`${pr.repo}#${pr.number}`, { at: Date.now(), pr });
-      job.resolve(result);
+      while (this.observations.size > 1000) this.observations.delete(this.observations.keys().next().value!);
+      job.resolve(result); accepted.push(result.id);
     }
-    if (!ready || !acceptJobs) return [];
-    const jobs = [...this.pending.values()].filter(p => !p.clientId && Date.parse(p.command.expiresAt) > Date.now()).slice(0, 1);
+    if (!ready || !acceptJobs) return { jobs: [], accepted };
+    const jobs = [...this.pending.values()].filter(p => !p.clientId && scopes.includes(p.command.repo.toLowerCase()) && Date.parse(p.command.expiresAt) > Date.now()).slice(0, 1);
     for (const job of jobs) job.clientId = clientId;
-    return jobs.map(j => j.command);
+    return { jobs: jobs.map(j => j.command), accepted };
   }
   request(op: BrowserCommand["op"], repo: string, prs: BrowserCommand["prs"]): Promise<BrowserResult> {
-    if (!this.status().ready) return Promise.reject(new Error(this.status().reason!));
-    const command = browserCommandSchema.parse({ id: randomUUID(), nonce: randomUUID(), expiresAt: new Date(Date.now() + 20_000).toISOString(), op, repo, prs });
+    if (!this.status(repo).ready) return Promise.reject(new Error(this.status(repo).reason!));
+    if (this.pending.size >= 50) return Promise.reject(new Error("Too many browser requests are pending."));
+    const budget = op === "read" ? 20_000 : 120_000;
+    const command = browserCommandSchema.parse({ id: randomUUID(), nonce: randomUUID(), expiresAt: new Date(Date.now() + budget).toISOString(), op, repo, prs });
     return new Promise(resolve => {
       const timer = setTimeout(() => {
         const leased = !!this.pending.get(command.id)?.clientId; this.pending.delete(command.id);
         resolve({ id: command.id, nonce: command.nonce, outcome: op !== "read" && leased ? "uncertain" : "failed", prs: [], applied: [], error: leased ? "Graphite did not confirm the result. Check state before trying again." : "The browser disconnected before this request was delivered." });
-      }, 20_000);
+      }, budget);
       this.pending.set(command.id, { command, clientId: null, timer, resolve });
     });
   }
   close() {
     for (const job of this.pending.values()) { clearTimeout(job.timer); job.resolve({ id: job.command.id, nonce: job.command.nonce, outcome: job.clientId && job.command.op !== "read" ? "uncertain" : "failed", prs: [], applied: [], error: "Follow-through reloaded before the request was confirmed. Check state." }); }
-    this.pending.clear();
+    this.pending.clear(); this.clients.clear(); this.observations.clear();
   }
 }

package/server/pr-actions.ts

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { downstack, mergeBlockers, type ActionPlan, type BrowserPr, type PrActionKind } from "../shared/pr-actions";
+import { downstack, mergeBlockers, prActionBlocks, type ActionPlan, type BrowserPr, type PrActionKind } from "../shared/pr-actions";
 import type { Workspace, Pr } from "../shared/model";
 import { findWorkspace } from "./engine";
 import { Store } from "./store";
@@ -19,6 +19,7 @@ export class PrActions {
   private plans = new Map<string, { plan: ActionPlan; identity: string }>();
   private reads = new Map<string, Promise<BrowserPr[]>>();
   private running = new Set<Promise<unknown>>();
+  private reviewerRequests = new Map<string, Promise<{ state: "submitted" | "failed" | "uncertain"; result: string }>>();
   constructor(private store: Store, private github: Pick<Github, "observe"> & Partial<Pick<Github, "requestReviewers">>, private graphite: Pick<Graphite, "merge" | "invalidate">, readonly browser: BrowserBridge, private now = Date.now, private reviewersFor = defaultReviewers) {}
 
   private async fresh(workspaceId: string): Promise<Workspace> {
@@ -44,7 +45,7 @@ export class PrActions {
     const w = findWorkspace(await this.store.snapshot(), workspaceId); active(w);
     const p = w.prs.find(p => p.key === key);
     if (!p) throw new Error("This PR is outside the workspace's inventory.");
-    const browser = this.browser.status();
+    const browser = this.browser.status(p.repo);
     if (!browser.ready || p.error || !p.snapshot?.complete || p.snapshot.state !== "OPEN") return { browser, pr: null, error: null };
     const cached = this.browser.cached(p.repo, p.number, p.snapshot.head);
     if (cached) return { browser, pr: cached, error: null };
@@ -59,7 +60,7 @@ export class PrActions {
     const prs = downstack(w.prs, key);
     if (!prs.length || prs.at(-1)?.key !== key) throw new Error("This PR is already merged.");
     const blockers: string[] = [];
-    if (w.prActions.some(a => ["sending", "uncertain"].includes(a.state))) blockers.push("Check the previous PR action before sending another.");
+    if (w.prActions.some(a => prActionBlocks(a, prs.map(p => p.key)))) blockers.push("Check the previous PR action before sending another.");
     if (kind === "merge" && w.prActions.some(a => a.kind === "merge" && a.state === "submitted" && prs.some(p => a.heads[p.key] === p.snapshot?.head) && this.now() - Date.parse(a.createdAt) < 30_000)) blockers.push("A merge was just submitted for this revision. Wait for Graphite's result.");
     const rows = prs.map(p => ({ key: p.key, repo: p.repo, number: p.number, title: p.snapshot?.title ?? p.stack, head: p.snapshot?.head ?? "", parent: p.parent, base: p.snapshot?.base ?? "", trunk: p.snapshot?.trunk ?? "", blockers: kind === "merge" ? mergeBlockers(p) : p.error || !p.snapshot?.complete || p.snapshot.state !== "OPEN" ? ["Refresh an open PR"] : kind === "enable_mwr" && p.snapshot.draft ? ["Draft"] : [] }));
     if (kind === "merge") {
@@ -83,8 +84,12 @@ export class PrActions {
     return work;
   }
   requestReviewers(workspaceId: string, key: string) {
-    const work = this.executeReviewers(workspaceId, key); this.running.add(work);
-    void work.finally(() => this.running.delete(work)).catch(() => undefined);
+    const requestKey = JSON.stringify([workspaceId, key]);
+    const pending = this.reviewerRequests.get(requestKey);
+    if (pending) return pending;
+    const work = this.executeReviewers(workspaceId, key);
+    this.reviewerRequests.set(requestKey, work); this.running.add(work);
+    void work.finally(() => { this.reviewerRequests.delete(requestKey); this.running.delete(work); }).catch(() => undefined);
     return work;
   }
   private async executeReviewers(workspaceId: string, key: string) {
@@ -101,7 +106,7 @@ export class PrActions {
     const id = randomUUID();
     await this.store.mutate(state => {
       const current = findWorkspace(state, workspaceId); active(current);
-      if (current.prActions.some(a => ["sending", "uncertain"].includes(a.state))) throw new Error("Check the previous PR action before sending another.");
+      if (current.prActions.some(a => prActionBlocks(a, [key]))) throw new Error("Check the previous PR action before sending another.");
       const latest = current.prs.find(p => p.key === key);
       if (!latest || latest.snapshot?.head !== pr.snapshot!.head || !noReviewers(latest)) throw new Error("PR status changed. Refresh before requesting reviews.");
       current.prActions.push({ id, kind: "request_reviewers", reviewers: reviewers.map(r => r.login), prs: [key], heads: { [key]: pr.snapshot!.head }, createdAt: new Date(this.now()).toISOString(), state: "sending", result: "Waiting for GitHub to confirm the review request." });
@@ -145,10 +150,10 @@ export class PrActions {
     const id = randomUUID();
     await this.store.mutate(state => {
       const current = findWorkspace(state, w.id); active(current);
-      if (current.prActions.some(a => ["sending", "uncertain"].includes(a.state))) throw new Error("A PR action is already in progress or needs checking.");
+      if (current.prActions.some(a => prActionBlocks(a, prs.map(p => p.key)))) throw new Error("A PR action is already in progress or needs checking.");
       if (plan.kind === "merge" && current.prActions.some(a => a.kind === "merge" && a.state === "submitted" && prs.some(p => a.heads[p.key] === p.snapshot?.head) && this.now() - Date.parse(a.createdAt) < 30_000)) throw new Error("A merge was just submitted for this revision. Wait for Graphite's result.");
       if (identity(downstack(current.prs, plan.target)) !== saved.identity) throw new Error("The stack changed before submission.");
-      current.prActions.push({ id, kind: plan.kind, prs: prs.map(p => p.key), heads: Object.fromEntries(prs.map(p => [p.key, p.snapshot!.head])), createdAt: new Date(this.now()).toISOString(), state: "sending", result: "Waiting for Graphite to confirm." });
+      current.prActions.push({ id, kind: plan.kind, prs: prs.map(p => p.key), heads: Object.fromEntries(prs.map(p => [p.key, p.snapshot!.head])), createdAt: new Date(this.now()).toISOString(), state: "sending", result: plan.kind === "merge" ? "Waiting for Graphite to confirm." : "Confirm this PR setting change in the Send to Paseo extension in Chrome." });
       current.completion = null;
     });
     let state: "submitted" | "failed" | "uncertain" = "submitted";

package/server/pr-owner.ts

@@ -0,0 +1,9 @@
+import type { State } from "../shared/model";
+
+/** Duplicate claims are ambiguous. Never route by recency or by PR title. */
+export function prOwner(state: State, repo: string, number: number) {
+  const claims = state.workspaces.filter(w => w.enable_tracking && !w.archived)
+    .flatMap(w => w.prs.filter(p => p.repo.toLowerCase() === repo.toLowerCase() && p.number === number)
+      .map(p => ({ workspaceId: w.id, agentId: p.registeredAgentId ?? w.mainAgentId })));
+  return claims.length === 1 ? claims[0] : null;
+}

package/shared/contracts.ts

@@ -41,3 +41,6 @@ export const projectSettingsRpc = defineRpc({ name: "follow.project-settings", i
 export const setProjectTrackingRpc = defineRpc({ name: "follow.set-project-tracking", input: z.object({ projectId: idSchema, enable_default_tracking: z.boolean() }), output: z.object({ projects: z.array(projectSchema) }) });
 export const refineTasksRpc = defineRpc({ name: "follow.refine-tasks", input: z.object({ workspaceId: idSchema, tasks: z.array(z.object({ id: idSchema, title: textSchema, afterPrs: z.array(idSchema), dependencyStage: z.enum(["merged", "deployed"]), enable_follow_up: z.boolean(), communication: communicationSchema.optional(), trigger: taskTriggerSchema.nullable().optional() })).max(50) }), output: workspaceSchema });
 export const taskTriggerRpc = defineRpc({ name: "follow.set-task-trigger", input: z.object({ workspaceId: idSchema, obligationId: idSchema, expectedRevision: z.number().int().nonnegative(), trigger: taskTriggerSchema.nullable(), afterPrs: z.array(idSchema) }), output: workspaceSchema });
+
+// Narrow integration: no inventory, messages, paths, or credentials cross this RPC.
+export const prOwnerRpc = defineRpc({ name: "follow.pr-owner", input: z.strictObject({ repo: z.string().regex(/^[\w.-]+\/[\w.-]+$/), number: z.number().int().positive() }), output: z.object({ owner: z.object({ workspaceId: idSchema, agentId: idSchema }).nullable() }) });

package/shared/model.ts

@@ -26,6 +26,7 @@ export const prSchema = z.object({
   key: idSchema, repo: z.string().regex(/^[\w.-]+\/[\w.-]+$/), number: z.number().int().positive(),
   stack: textSchema, parent: idSchema.nullable(), disposition: z.string().nullable(),
   snapshot: snapshotSchema.nullable(), error: z.string().nullable(),
+  registeredAgentId: idSchema.optional(),
   deploymentAnchor: z.object({ mergeCommit: z.string(), at: z.string() }).optional(),
 });
 export const obligationSchema = z.object({

package/shared/pr-actions.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { idSchema, textSchema, type Pr } from "./model";
+import { idSchema, textSchema, type Pr, type Workspace } from "./model";
 
 export const prActionKind = z.enum(["merge", "enable_mwr", "disable_mwr"]);
 export const actionPrSchema = z.object({ key: idSchema, repo: z.string(), number: z.number(), title: z.string(), head: z.string(), parent: idSchema.nullable(), base: z.string(), trunk: z.string(), blockers: z.array(z.string()) });
@@ -13,7 +13,7 @@ export const browserCommandSchema = z.object({ id: idSchema, nonce: idSchema, ex
 export type BrowserCommand = z.infer<typeof browserCommandSchema>;
 export const browserResultSchema = z.object({ id: idSchema, nonce: idSchema, outcome: z.enum(["completed", "failed", "uncertain"]), prs: z.array(browserPrSchema).max(50).default([]), applied: z.array(z.number().int().positive()).max(50).default([]), error: z.string().max(500).default("") });
 export type BrowserResult = z.infer<typeof browserResultSchema>;
-export const browserExchangeSchema = z.object({ clientId: idSchema, ready: z.boolean(), acceptJobs: z.boolean().default(true), results: z.array(browserResultSchema).max(10).default([]) });
+export const browserExchangeSchema = z.object({ clientId: idSchema, ready: z.boolean(), acceptJobs: z.boolean().default(true), results: z.array(browserResultSchema).max(10).default([]), repositories: z.array(browserPrSchema.shape.repo).max(100).default([]) });
 export const browserStatusSchema = z.object({ ready: z.boolean(), reason: z.string().nullable() });
 export const actionResultSchema = z.object({ state: z.enum(["submitted", "failed", "uncertain"]), result: textSchema });
 
@@ -45,3 +45,9 @@ export function mergeBlockers(pr: Pr): string[] {
   if (!["READY_TO_MERGE", "READY_TO_MERGE_AS_STACK", "READY_TO_MERGE_WITHOUT_CI", "READY_TO_MERGE_AS_STACK_WITHOUT_CI"].includes(s.graphiteMergeStatus ?? "")) blockers.push("Graphite is not ready to merge");
   return blockers;
 }
+
+/** Reviewer requests on other PRs do not own this PR's action slot. */
+export function prActionBlocks(action: Pick<Workspace["prActions"][number], "state" | "kind" | "prs">, keys: readonly string[]): boolean {
+  return ["sending", "uncertain"].includes(action.state) &&
+    (action.kind !== "request_reviewers" || action.prs.some(key => keys.includes(key)));
+}