paseo-follow-up 0.1.2 → 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.11+, 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

@@ -2,7 +2,7 @@
 
 [![npm version](https://img.shields.io/npm/v/paseo-follow-up?style=for-the-badge&color=cb3837)](https://www.npmjs.com/package/paseo-follow-up)
 [![npm downloads](https://img.shields.io/npm/dm/paseo-follow-up?style=for-the-badge&color=cb3837)](https://www.npmjs.com/package/paseo-follow-up)
-[![Paseo](https://img.shields.io/badge/Paseo-%E2%89%A5%200.11.0-8A63D2?style=for-the-badge)](https://paseo.sh)
+[![Paseo](https://img.shields.io/badge/Paseo-%E2%89%A5%200.14.0-8A63D2?style=for-the-badge)](https://paseo.sh)
 [![License](https://img.shields.io/github/license/tomgrin10/paseo-follow-up?style=for-the-badge&color=2563eb)](LICENSE)
 
 Keep long-lived Paseo workspaces moving through review, deployment, and completion. Follow-up retains PR stacks and remaining tasks, batches repairs for the existing main agent, and records the agent's explicit Done declaration.
@@ -13,7 +13,7 @@ Screenshots use synthetic workspaces and PRs.
 
 ## Requirements
 
-- Paseo 0.11.0 or newer and Node 22 or newer.
+- Paseo 0.14.0 or newer and Node 22 or newer.
 - Authenticated GitHub CLI (`gh`) on the daemon host.
 - Saved Graphite CLI authentication for Graphite readiness and explicit Merge controls.
 - Optional Send to Paseo browser companion for Graphite's actual Merge when ready switch. Core tracking and follow-up work without it.
@@ -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.
@@ -63,6 +79,16 @@ Integration checks use a separate Paseo home, synthetic agents and fixtures. Nev
 
 Release tags (`vX.Y.Z`) run `.github/workflows/publish-npm.yml`. GitHub Actions verifies the plugin and packed installation, publishes through npm Trusted Publishing, verifies registry integrity, then creates the GitHub release. No npm token is stored in repository secrets.
 
+## Paseo 0.14 agent integration
+
+The Follow-up MCP attaches when a tracked main or active recovery agent opens a Claude or Codex session. Normal startup no longer writes global Claude/Codex MCP settings. Existing global entries are preserved. Turn-ended discovery now fetches recent history through the SDK because Paseo 0.13+ sends an empty timeline in lifecycle events.
+
+Requires Paseo **0.14.0 or newer**. Agent tools are scoped to interactive Claude
+and Codex sessions; history-only opens receive none. They become available on
+the next idle session open after install or reload. The agent label
+`plugin-tools/enabled: "false"` opts a session out. Existing plugin data and
+settings are retained.
+
 ## Other plugins
 
 Also available from [Tom Gringauz](https://github.com/tomgrin10):

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";
@@ -18,7 +19,7 @@ import { applyHistory, applyDiscovery, extractHistory } from "./server/discovery
 import { lifecycleOnly, recoveryBatch } from "./shared/follow-up";
 import { Deployments } from "./server/deployments";
 import { AgentHooks } from "./server/agent-hooks";
-import { AgentMcp } from "./server/agent-mcp";
+import { withSessionMcp } from "./server/session-mcp";
 import { updateObligation } from "./server/obligations";
 
 export default function contribute(server: PluginServerContext) {
@@ -27,7 +28,6 @@ export default function contribute(server: PluginServerContext) {
   const bridge = join(directory, "mcp.mjs");
   const store = new Store(directory);
   const agentHooks = new AgentHooks(directory, clientEntry());
-  const agentMcp = new AgentMcp(directory, clientEntry(), paseoHome);
   const gateway = new PaseoGateway();
   const graphite = new Graphite();
   const github = new Github(undefined, graphite, new Deployments());
@@ -48,8 +48,6 @@ export default function contribute(server: PluginServerContext) {
     await engine.recover();
     hooksStarted = true;
     await agentHooks.start().catch(() => { hookError = "Automatic sidebar instructions could not be registered for every provider. Check Claude/Codex hook settings; tracking is still available."; });
-    const mcp = await agentMcp.start();
-    if ([mcp.claude, mcp.codex].some(status => ["unavailable", "name-conflict"].includes(status))) hookError = "Some agent MCP connections could not be registered. Existing CLI access remains available.";
     hookTimer = setInterval(() => void agentHooks.heartbeat().catch(() => {}), 30_000);
   })().catch(() => { loadError = "Follow-through could not start. Check its saved state and worker lock."; });
   const requireReady = async () => { await ready; if (loadError || stopped) throw new Error(loadError ?? "Follow-through is stopping"); };
@@ -96,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 }) => {
@@ -148,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;
@@ -238,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; });
@@ -252,9 +258,9 @@ export default function contribute(server: PluginServerContext) {
     }),
     server.before("agent.session_open", async ({ request }) => {
       await ready;
-      if (loadError || stopped) return request;
+      if (loadError || stopped || request.purpose !== "interactive") return request;
       const saved = await store.snapshot();
-      let w = saved.workspaces.find(w => w.enable_tracking && (w.mainAgentId === request.agentId || w.batches.some(b => b.recipientAgentId === request.agentId)));
+      let w = saved.workspaces.find(w => w.enable_tracking && !w.archived && (w.mainAgentId === request.agentId || w.batches.some(b => b.recipientAgentId === request.agentId && !b.settledAt && b.tasks.every(t => t.kind === "inventory") && ["sending", "sent", "uncertain", "blocked"].includes(b.state))));
       if (!w && request.workspaceId && !saved.workspaces.some(w => w.id === request.workspaceId && (w.archived || w.mainAgentId !== request.agentId))) {
         const project = await gateway.projectForWorkspace(saved, request.workspaceId).catch(() => null);
         if (project?.enable_default_tracking) {
@@ -267,9 +273,10 @@ export default function contribute(server: PluginServerContext) {
         }
       }
       if (!w) return request;
-      return { ...request, env: { ...request.env, FOLLOW_THROUGH_CLI: bridge, FOLLOW_THROUGH_CLIENT_ENTRY: clientEntry(), ...(w.mainAgentId !== request.agentId ? { FOLLOW_THROUGH_RECOVERY: "1" } : {}) } };
+      const recovery = w.mainAgentId !== request.agentId;
+      return withSessionMcp({ ...request, env: { ...request.env, FOLLOW_THROUGH_CLI: bridge, FOLLOW_THROUGH_CLIENT_ENTRY: clientEntry(), ...(recovery ? { FOLLOW_THROUGH_RECOVERY: "1" } : {}) } }, directory, clientEntry(), paseoHome, recovery);
     }),
-    server.on("agent.turn_ended", async event => {
+    server.on("agent.turn_ended", async (event, { paseo, signal }) => {
       await ready;
       if (stopped || loadError) return;
       const interruption = event.outcome.kind === "canceled" || event.outcome.kind === "failed" ? { turnId: event.turnId, at: new Date().toISOString(), kind: event.outcome.kind } : null;
@@ -281,9 +288,13 @@ export default function contribute(server: PluginServerContext) {
       }
       if (!(await store.snapshot()).workspaces.some(w => w.enable_tracking && w.mainAgentId === event.agent.id)) return;
       gateway.markDirty(event.agent.id);
-      await store.mutate(state => {
+      // Since Paseo 0.13 the lifecycle payload deliberately contains no history.
+      // Read a bounded tail through the plugin-owned API, outside the state lock.
+      const history = await paseo.agents.ref(event.agent.id).timeline.refetch({ direction: "tail", limit: 100, projection: "canonical" }).catch(() => null);
+      if (signal.aborted || stopped) return;
+      if (history) await store.mutate(state => {
         const w = state.workspaces.find(w => w.enable_tracking && w.mainAgentId === event.agent.id);
-        if (w) applyHistory(w, extractHistory(event.timeline), null);
+        if (w) applyHistory(w, extractHistory(history.entries.map(entry => entry.item), w.inventory?.historyComplete ?? false, w.inventory?.historyError ?? null), null);
       });
       const guarded = interruption && await sessionGuardOwnsInterruption(event.agent.id, interruption).catch(() => false);
       if (["canceled", "failed"].includes(event.outcome.kind) && !guarded) await store.mutate(state => {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "paseo-follow-up",
   "private": false,
-  "version": "0.1.2",
+  "version": "0.3.0",
   "description": "Track workspace pull requests, queue follow-up work, and verify completion in Paseo.",
   "type": "module",
   "files": [
@@ -28,8 +28,8 @@
     "prepare": "node scripts/build.mjs"
   },
   "devDependencies": {
-    "@getpaseo/client": "0.11.0",
-    "@getpaseo/plugin": "0.11.0",
+    "@getpaseo/client": "0.14.0",
+    "@getpaseo/plugin": "0.14.0",
     "@tanstack/react-query": "^5.90.11",
     "@types/node": "^22.10.2",
     "@types/react": "~19.2.0",

package/paseo-plugin.json

@@ -7,6 +7,6 @@
     "docs/screenshots/follow-up-overview.png"
   ],
   "requirements": {
-    "paseo": ">=0.11.0"
+    "paseo": ">=0.14.0"
   }
 }

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/server/session-mcp.ts

@@ -0,0 +1,15 @@
+import type { PluginSessionOpenRequest } from "@getpaseo/plugin/server";
+import { mcpDefinition } from "./agent-mcp";
+
+/** The bridge and caller identity belong to this launch, never global CLI config. */
+export function withSessionMcp(request: PluginSessionOpenRequest, directory: string, clientEntry: string, home: string, recovery: boolean, env: NodeJS.ProcessEnv = process.env): PluginSessionOpenRequest {
+  if (request.purpose !== "interactive" || !["claude", "codex"].includes(request.provider) || request.labels["plugin-tools/enabled"] === "false") return request;
+  const definition = mcpDefinition(directory, clientEntry, home);
+  return { ...request, mcpServers: { ...request.mcpServers, "follow-through": { ...definition, env: {
+    ...definition.env, PASEO_AGENT_ID: request.agentId,
+    ...(recovery ? { FOLLOW_THROUGH_RECOVERY: "1" } : {}),
+    ...(env.PASEO_DAEMON_URL ? { PASEO_DAEMON_URL: env.PASEO_DAEMON_URL } : {}),
+    ...(env.PASEO_PASSWORD ? { PASEO_PASSWORD: env.PASEO_PASSWORD } : {}),
+    ...(env.PASEO_PASSWORD_FILE ? { PASEO_PASSWORD_FILE: env.PASEO_PASSWORD_FILE } : {}),
+  } } } };
+}

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)));
+}