From a87a8b0dfb999118c5da8e3878cfc55a9bcaad34 Mon Sep 17 00:00:00 2001
From: Ravneet Arora <rarora@squareup.com>
Date: Wed, 11 Nov 2026 12:33:34 -0500
Subject: [PATCH 01/17] Add review configuration plugin

Save channel-scoped repository and lane settings through the existing
signed relay artifact path. Keep configuration separate from review
execution and preserve drafts on failed saves or reconnects.

Co-authored-by: maincourse <37ce551b493d4a998caf030929c47bce0b6a0e43f1178b3a63c4151d7c16b76e@buzz.block.builderlab.xyz>
Signed-off-by: Ravneet Arora <rarora@squareup.com>
---
 docs/buzz-help.md                             |   9 +
 src/app/shell/presentation.ts                 |   2 +
 src/bundled/index.ts                          |   7 +
 src/bundled/navigation-owner.test.ts          |   1 +
 src/bundled/review-configuration/README.md    |  62 +++
 .../ReviewConfigurationPage.test.tsx          | 248 +++++++++
 .../ReviewConfigurationPage.tsx               | 505 ++++++++++++++++++
 .../configuration.test.ts                     | 226 ++++++++
 .../review-configuration/configuration.ts     | 196 +++++++
 src/bundled/review-configuration/index.tsx    |  15 +
 .../review-configuration/manifest.json        |   7 +
 .../review-configuration.css                  |  44 ++
 12 files changed, 1322 insertions(+)
 create mode 100644 src/bundled/review-configuration/README.md
 create mode 100644 src/bundled/review-configuration/ReviewConfigurationPage.test.tsx
 create mode 100644 src/bundled/review-configuration/ReviewConfigurationPage.tsx
 create mode 100644 src/bundled/review-configuration/configuration.test.ts
 create mode 100644 src/bundled/review-configuration/configuration.ts
 create mode 100644 src/bundled/review-configuration/index.tsx
 create mode 100644 src/bundled/review-configuration/manifest.json
 create mode 100644 src/bundled/review-configuration/review-configuration.css

diff --git a/docs/buzz-help.md b/docs/buzz-help.md
index b7caebe750..7899199002 100644
--- a/docs/buzz-help.md
+++ b/docs/buzz-help.md
@@ -1153,6 +1153,15 @@ confirmation. **Delete team** asks first; it doesn't delete the team's agents.
   local installs. Upgrades preserve their previous state, including Bestie off
   when no choice was saved. Enable or disable them in **Manage plugins**; saved
   choices persist. A deliberate plugin-settings reset uses the current defaults.
+- **Review Configuration** is optional and starts off. Enable it in **Manage
+  plugins** to add its own Messages sidebar entry. Choose a review channel,
+  register a GitHub repository, and save named lanes with instructions. Saved
+  repositories appear in a table; **Edit** changes their settings and **Reload**
+  reads the latest saved versions. Settings live on the community relay and are
+  visible to channel readers; members who can post can edit them. A conflicting
+  edit preserves your draft: copy your changes before cancelling and reloading.
+  This first version saves configuration only. It does not assign reviewers,
+  submit PRs, or send the planned 15-minute reminders.
 - A plugin's details in Manage plugins link to the Settings sections that hold
   its settings: sections it adds, such as GitHub comment authors, and Decisions
   API for a decision provider, such as TypeSafe. Only sections the Settings
diff --git a/src/app/shell/presentation.ts b/src/app/shell/presentation.ts
index e0505dd48f..9180b44a0c 100644
--- a/src/app/shell/presentation.ts
+++ b/src/app/shell/presentation.ts
@@ -6,6 +6,7 @@ import {
   NoteIcon,
   GearIcon,
   LightningIcon,
+  ListChecksIcon,
   RobotIcon,
   SendIcon,
 } from "../../shared/design-system/icons/index";
@@ -58,6 +59,7 @@ const bundledIcons = new Map<string, typeof BrowserIcon>([
   ["buzz.reminders/reminders", AlarmIcon],
   ["buzz.agents/agents", RobotIcon],
   ["buzz.workflows/workflows", LightningIcon],
+  ["buzz.review-configuration/configuration", ListChecksIcon],
   ["buzz.relay-notes/notes", NoteIcon],
 ]);
 /** Resolve host navigation policy once, independently of icons and registrations. */
diff --git a/src/bundled/index.ts b/src/bundled/index.ts
index 6077e70036..3c223b3b22 100644
--- a/src/bundled/index.ts
+++ b/src/bundled/index.ts
@@ -60,6 +60,8 @@ import reposManifest from "./repos/manifest.json";
 import * as repos from "./repos";
 import workflowsManifest from "./workflows/manifest.json";
 import * as workflows from "./workflows";
+import reviewConfigurationManifest from "./review-configuration/manifest.json";
+import * as reviewConfiguration from "./review-configuration";
 import type { BundledPlugin } from "../plugins/manager";
 import linksManifest from "./links/manifest.json";
 import * as links from "./links";
@@ -251,6 +253,11 @@ export const bundledPlugins: readonly BundledPlugin[] = [
     module: workflows,
     enabledByDefault: false,
   },
+  {
+    manifest: { ...reviewConfigurationManifest, apiVersion: 1 },
+    module: reviewConfiguration,
+    enabledByDefault: false,
+  },
   {
     manifest: { ...moderationManifest, apiVersion: 1 },
     module: moderation,
diff --git a/src/bundled/navigation-owner.test.ts b/src/bundled/navigation-owner.test.ts
index 964da081b0..130008dc7c 100644
--- a/src/bundled/navigation-owner.test.ts
+++ b/src/bundled/navigation-owner.test.ts
@@ -47,6 +47,7 @@ it("gives every bundled page to the app whose navigation lists it", async () =>
     // Pages listed in the Messages sidebar keep Messages selected.
     "buzz.drafts-and-sent/drafts-sent": messages,
     "buzz.inbox/inbox": messages,
+    "buzz.review-configuration/configuration": messages,
     // Dock apps own themselves.
     "buzz.bestie/bestie": "buzz.bestie/bestie",
     "buzz.reminders/reminders": "buzz.reminders/reminders",
diff --git a/src/bundled/review-configuration/README.md b/src/bundled/review-configuration/README.md
new file mode 100644
index 0000000000..933723e31c
--- /dev/null
+++ b/src/bundled/review-configuration/README.md
@@ -0,0 +1,62 @@
+# Review Configuration
+
+An optional bundled plugin with a separate sidebar page for repository review
+settings. Enable **Review Configuration** in Settings → Plugins → Manage plugins.
+Choose a channel, register a GitHub repository, add named lanes and instructions,
+and save. The repository table supports editing and an explicit reload.
+
+This is configuration only. It does not submit PRs, choose reviewers, create
+review threads, or send reminders. No agent or timer runs in the background.
+
+## Storage and access
+
+`configuration.ts` owns the save/load boundary. Each channel/repository pair has
+one deterministic NIP-AR artifact of type `buzz.review.config` (kind 45010).
+The signed event's `h` tag is its review channel. Its content is:
+
+```json
+{
+  "version": 1,
+  "repository": "example-org/project",
+  "lanes": [
+    {
+      "id": "general",
+      "name": "General",
+      "instructions": "Check authorization, error handling, and tests."
+    }
+  ],
+  "reminderMinutes": 15
+}
+```
+
+The existing relay artifact writer persists the current head in `artifact_heads`,
+the accepted revisions in `artifact_revisions`, and the signed payload in `events`.
+There is no new SQL migration or local-only settings store. Ordinary channel
+authorization applies: readers can see instructions, and members who can post
+can edit them. Configuration is scoped to a channel, not globally unique across
+the community. No GitHub credentials are stored or requested, and repository
+existence/access is not checked in this first slice.
+
+Edits carry the revision that the form loaded in `prev`; the relay rejects a
+stale edit atomically. A failed or uncertain save keeps the draft. Copy any
+changes before Cancel → Reload, then inspect the saved version before retrying.
+An unsupported or malformed row shows a warning without hiding valid rows.
+Channel metadata reconfirmation disables Save while retaining an open draft.
+
+Opening a channel or clicking Reload makes one bounded snapshot query. There
+are no reconnect subscriptions or polling timers. The first version supports
+100 configurations per channel, 12 lanes per repository, and a 32 KB payload.
+Larger result sets are explicitly marked incomplete; use a separate channel.
+The reminder interval is saved for the planned executor but has no effect yet.
+
+## Try it
+
+1. Enable the plugin and open **Review Configuration** in the Messages sidebar.
+2. Choose a writable stream or forum channel and click **Register repository**.
+3. Enter a repository and lane instructions, then **Save settings**.
+4. Reload the page, choose the same channel, and verify the repository row.
+5. Edit the instructions, save, and use **Reload** to confirm the new version.
+6. In two clients, edit the same version; the second save must fail without
+   discarding its draft after the first client saves.
+
+Use a test channel. Saving does not activate any review automation.
diff --git a/src/bundled/review-configuration/ReviewConfigurationPage.test.tsx b/src/bundled/review-configuration/ReviewConfigurationPage.test.tsx
new file mode 100644
index 0000000000..2e7b961126
--- /dev/null
+++ b/src/bundled/review-configuration/ReviewConfigurationPage.test.tsx
@@ -0,0 +1,248 @@
+// @vitest-environment jsdom
+import { act, cleanup, render, screen, waitFor } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { afterEach, expect, it, vi } from "vitest";
+import type { EventTemplate } from "nostr-tools";
+import type { RelaySession } from "../../features/relay/session";
+import type { ChannelSummary } from "../../features/relay/contracts";
+import type { EventData } from "../../features/relay/events";
+import { keypair, signed } from "../../features/relay/testing";
+import { ReviewConfigurationCommunity } from "./ReviewConfigurationPage";
+
+afterEach(cleanup);
+const channel = "11111111-1111-4111-8111-111111111111";
+function fixture() {
+  const key = keypair();
+  let events: EventData[] = [];
+  let list = {
+    status: "ready",
+    channels: [
+      { id: channel, name: "Reviews", channelType: "stream" } as ChannelSummary,
+    ],
+  };
+  const listeners = new Set<() => void>();
+  const snapshotRead = vi.fn(async () => events);
+  const publish = vi.fn(async (event: EventData) => {
+    events = [event];
+    return event.id;
+  });
+  const session = {
+    channels: {
+      ensureList() {},
+      list: () => list,
+      subscribeList: (listener: () => void) => {
+        listeners.add(listener);
+        return () => listeners.delete(listener);
+      },
+    },
+    snapshotRead,
+    configArtifactWriter: {
+      sign: async (template: EventTemplate) => signed(key, template),
+      publish,
+    },
+  } as unknown as RelaySession;
+  return {
+    session,
+    publish,
+    snapshotRead,
+    metadataCached(cached: boolean) {
+      list = {
+        ...list,
+        channels: [
+          {
+            id: channel,
+            name: "Reviews",
+            channelType: "stream",
+            ...(cached ? { metadataCached: true } : {}),
+          },
+        ],
+      };
+      for (const listener of listeners) listener();
+    },
+  };
+}
+
+async function openDraft() {
+  const user = userEvent.setup();
+  await user.click(screen.getByRole("combobox", { name: "Review channel" }));
+  await user.click(await screen.findByRole("option", { name: "Reviews" }));
+  await screen.findByText(
+    "No repositories configured in this channel. Register one to save its review lanes.",
+  );
+  await user.click(screen.getByRole("button", { name: "Register repository" }));
+  await user.type(
+    screen.getByRole("textbox", { name: "GitHub repository" }),
+    "example-org/project",
+  );
+  await user.type(
+    screen.getByRole("textbox", { name: "Lane 1 instructions" }),
+    "Check authorization and keyboard navigation.",
+  );
+  return user;
+}
+
+it("registers, reloads and edits a repository through the real form and artifact writer", async () => {
+  const test = fixture();
+  render(<ReviewConfigurationCommunity session={test.session} />);
+  const user = await openDraft();
+  await user.click(screen.getByRole("button", { name: "Save settings" }));
+  await screen.findByText(
+    "Saved example-org/project. Reviews are not enabled yet.",
+  );
+  await user.click(screen.getByRole("button", { name: "Reload" }));
+  await screen.findByRole("button", { name: "Edit example-org/project" });
+  await user.click(
+    screen.getByRole("button", { name: "Edit example-org/project" }),
+  );
+  expect(
+    (
+      screen.getByRole("textbox", {
+        name: "Lane 1 instructions",
+      }) as HTMLTextAreaElement
+    ).value,
+  ).toBe("Check authorization and keyboard navigation.");
+  await user.clear(
+    screen.getByRole("textbox", { name: "Lane 1 instructions" }),
+  );
+  await user.type(
+    screen.getByRole("textbox", { name: "Lane 1 instructions" }),
+    "Check database migrations.",
+  );
+  await user.click(screen.getByRole("button", { name: "Save settings" }));
+  await screen.findByText(
+    "Saved example-org/project. Reviews are not enabled yet.",
+  );
+  expect(test.publish).toHaveBeenCalledTimes(2);
+  expect(test.publish.mock.calls[1]?.[0].tags).toContainEqual([
+    "prev",
+    test.publish.mock.calls[0]?.[0].id,
+  ]);
+});
+
+it("keeps the draft on rejection, prevents duplicate submissions, and recovers", async () => {
+  const test = fixture();
+  let reject: (error: Error) => void = () => {};
+  test.publish.mockImplementationOnce(
+    () =>
+      new Promise((_resolve, rejectSave) => {
+        reject = rejectSave;
+      }),
+  );
+  render(<ReviewConfigurationCommunity session={test.session} />);
+  const user = await openDraft();
+  await user.dblClick(screen.getByRole("button", { name: "Save settings" }));
+  await waitFor(() => expect(test.publish).toHaveBeenCalledTimes(1));
+  expect(
+    (screen.getByRole("button", { name: "Cancel" }) as HTMLButtonElement)
+      .disabled,
+  ).toBe(true);
+  await act(async () => reject(new Error("conflict: artifact head changed")));
+  expect((await screen.findByRole("alert")).textContent).toContain(
+    "Your draft is still here",
+  );
+  expect(
+    (
+      screen.getByRole("textbox", {
+        name: "Lane 1 instructions",
+      }) as HTMLTextAreaElement
+    ).value,
+  ).toContain("keyboard navigation");
+  await user.click(screen.getByRole("button", { name: "Save settings" }));
+  await screen.findByText(
+    "Saved example-org/project. Reviews are not enabled yet.",
+  );
+});
+
+it("preserves the draft while channel authorization reconfirms, but gates Save", async () => {
+  const test = fixture();
+  render(<ReviewConfigurationCommunity session={test.session} />);
+  await openDraft();
+  act(() => test.metadataCached(true));
+  expect(
+    (screen.getByRole("button", { name: "Save settings" }) as HTMLButtonElement)
+      .disabled,
+  ).toBe(true);
+  expect(
+    (
+      screen.getByRole("textbox", {
+        name: "Lane 1 instructions",
+      }) as HTMLTextAreaElement
+    ).value,
+  ).toContain("keyboard navigation");
+  act(() => test.metadataCached(false));
+  expect(
+    (screen.getByRole("button", { name: "Save settings" }) as HTMLButtonElement)
+      .disabled,
+  ).toBe(false);
+  expect(
+    (
+      screen.getByRole("textbox", {
+        name: "Lane 1 instructions",
+      }) as HTMLTextAreaElement
+    ).value,
+  ).toContain("keyboard navigation");
+  expect(test.publish).not.toHaveBeenCalled();
+});
+
+it("aborts an unfinished write when the page leaves its session", async () => {
+  const test = fixture();
+  const publish = vi.fn(
+    (_event: EventData, signal: AbortSignal) =>
+      new Promise<string>((_resolve, reject) =>
+        signal.addEventListener("abort", () => reject(signal.reason)),
+      ),
+  );
+  const session = {
+    ...test.session,
+    configArtifactWriter: { ...test.session.configArtifactWriter, publish },
+  } as RelaySession;
+  const view = render(<ReviewConfigurationCommunity session={session} />);
+  const user = await openDraft();
+  await user.click(screen.getByRole("button", { name: "Save settings" }));
+  await waitFor(() => expect(publish).toHaveBeenCalledTimes(1));
+  view.unmount();
+  expect(publish.mock.calls[0]?.[1].aborted).toBe(true);
+});
+
+it("counts unreadable records toward the limit when a new repository is saved", async () => {
+  const test = fixture();
+  test.snapshotRead.mockResolvedValueOnce(
+    Array.from({ length: 99 }, () => ({
+      kind: 45010,
+      id: "a".repeat(64),
+      pubkey: "b".repeat(64),
+      sig: "",
+      created_at: 1,
+      tags: [
+        ["h", channel],
+        ["type", "buzz.review.config"],
+      ],
+      content: "{broken",
+    })),
+  );
+  render(<ReviewConfigurationCommunity session={test.session} />);
+  const user = userEvent.setup();
+  await user.click(screen.getByRole("combobox", { name: "Review channel" }));
+  await user.click(await screen.findByRole("option", { name: "Reviews" }));
+  await screen.findByText("No readable configurations in this channel.");
+  await user.click(screen.getByRole("button", { name: "Register repository" }));
+  await user.type(
+    screen.getByRole("textbox", { name: "GitHub repository" }),
+    "example-org/project",
+  );
+  await user.type(
+    screen.getByRole("textbox", { name: "Lane 1 instructions" }),
+    "Check tests.",
+  );
+  await user.click(screen.getByRole("button", { name: "Save settings" }));
+  await screen.findByText(
+    "Saved example-org/project. Reviews are not enabled yet.",
+  );
+  expect(
+    (
+      screen.getByRole("button", {
+        name: "Register repository",
+      }) as HTMLButtonElement
+    ).disabled,
+  ).toBe(true);
+});
diff --git a/src/bundled/review-configuration/ReviewConfigurationPage.tsx b/src/bundled/review-configuration/ReviewConfigurationPage.tsx
new file mode 100644
index 0000000000..cd1fbc4718
--- /dev/null
+++ b/src/bundled/review-configuration/ReviewConfigurationPage.tsx
@@ -0,0 +1,505 @@
+import { useEffect, useRef, useState, type ReactNode } from "react";
+import { useChannelList, useRelayConnection } from "../../features/relay/react";
+import type { RelayData } from "../../features/relay/service";
+import type { RelaySession } from "../../features/relay/session";
+import { ListChecksIcon } from "../../shared/design-system/icons";
+import { Button } from "../../shared/design-system/ui/Button";
+import { Field } from "../../shared/design-system/ui/Field";
+import { FullPageSurface } from "../../shared/design-system/ui/FullPageSurface";
+import { InlineHeader } from "../../shared/design-system/ui/Header";
+import { Input } from "../../shared/design-system/ui/Input";
+import {
+  PanelHeader,
+  PanelHeaderLabel,
+} from "../../shared/design-system/ui/PanelHeader";
+import { Select } from "../../shared/design-system/ui/Select";
+import { SettingsGroup } from "../../shared/design-system/ui/SettingsGroup";
+import { Textarea } from "../../shared/design-system/ui/Textarea";
+import {
+  loadConfigurations,
+  repositoryName,
+  saveConfiguration,
+  type ReviewConfig,
+  type SavedReviewConfig,
+} from "./configuration";
+import "./review-configuration.css";
+
+function Frame({ children }: { children: ReactNode }) {
+  return (
+    <FullPageSurface aria-label="Review Configuration">
+      <div className="review-config-page text-body">
+        <PanelHeader
+          title={
+            <PanelHeaderLabel
+              title="Review Configuration"
+              icon={<ListChecksIcon />}
+            />
+          }
+        />
+        <div className="review-config-scroll">
+          <div className="review-config-content">{children}</div>
+        </div>
+      </div>
+    </FullPageSurface>
+  );
+}
+
+export function ReviewConfigurationPage({ relay }: { relay: RelayData }) {
+  const connection = useRelayConnection(relay);
+  if (connection.status === "ready")
+    return (
+      <ReviewConfigurationCommunity
+        key={`${connection.scope}:${connection.generation}`}
+        session={connection.session}
+      />
+    );
+  return (
+    <Frame>
+      <p>
+        {connection.status === "connecting"
+          ? "Connecting to your community…"
+          : "Connect to a community to configure reviews."}
+      </p>
+      {connection.status === "error" && (
+        <>
+          <p role="alert">{connection.error}</p>
+          <Button onClick={() => relay.retry()}>Retry connection</Button>
+        </>
+      )}
+    </Frame>
+  );
+}
+
+export function ReviewConfigurationCommunity({
+  session,
+}: {
+  session: RelaySession;
+}) {
+  const list = useChannelList(session.channels);
+  const [channel, setChannel] = useState("");
+  const [editing, setEditing] = useState(false);
+  const channels = list.channels.filter(
+    (item) =>
+      !item.metadataPending &&
+      !item.huddle &&
+      !item.archived &&
+      !item.pending &&
+      (item.channelType === "stream" || item.channelType === "forum"),
+  );
+  const selected = channels.find((item) => item.id === channel);
+  const writable =
+    !!selected &&
+    !selected.metadataCached &&
+    !selected.cached &&
+    !selected.readOnly &&
+    !!session.configArtifactWriter;
+  return (
+    <Frame>
+      <p>
+        Register repositories and save their review lane instructions. These are
+        draft settings; saving does not start reviews or send reminders.
+      </p>
+      <Select
+        label="Review channel"
+        variant="field"
+        value={channel}
+        onValueChange={setChannel}
+        disabled={editing}
+        placeholder="Choose a channel"
+        groups={[
+          {
+            label: "Channels",
+            options: channels.map((item) => ({
+              value: item.id,
+              label: item.name,
+            })),
+          },
+        ]}
+        description="Settings are shared with this channel. Members who can post can edit them. Choose a private channel for private instructions."
+      />
+      {list.status === "loading" && <p role="status">Loading channels…</p>}
+      {list.status === "error" && (
+        <p role="alert">Could not load channels. Reconnect to try again.</p>
+      )}
+      {channel && !writable && (
+        <p role="alert">
+          Saving is unavailable until channel access is confirmed. Your open
+          draft is preserved.
+        </p>
+      )}
+      {channel && (
+        <ChannelConfiguration
+          key={channel}
+          session={session}
+          channel={channel}
+          writable={writable}
+          onEditingChange={setEditing}
+        />
+      )}
+    </Frame>
+  );
+}
+
+function ChannelConfiguration({
+  session,
+  channel,
+  writable,
+  onEditingChange,
+}: {
+  session: RelaySession;
+  channel: string;
+  writable: boolean;
+  onEditingChange: (editing: boolean) => void;
+}) {
+  const [rows, setRows] = useState<SavedReviewConfig[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState("");
+  const [notice, setNotice] = useState("");
+  const [warning, setWarning] = useState("");
+  const [remaining, setRemaining] = useState(0);
+  const [reload, setReload] = useState(0);
+  const [editor, setEditor] = useState<SavedReviewConfig | "new">();
+  const editorTrigger = useRef<HTMLButtonElement | null>(null);
+  useEffect(() => {
+    onEditingChange(editor !== undefined);
+    if (editor === undefined) editorTrigger.current?.focus();
+    return () => onEditingChange(false);
+  }, [editor, onEditingChange]);
+  // biome-ignore lint/correctness/useExhaustiveDependencies: Reload explicitly requests a fresh snapshot.
+  useEffect(() => {
+    const controller = new AbortController();
+    setLoading(true);
+    setError("");
+    loadConfigurations(
+      session,
+      channel,
+      AbortSignal.any([controller.signal, AbortSignal.timeout(20_000)]),
+    )
+      .then((next) => {
+        if (!controller.signal.aborted) {
+          setRows(next.rows);
+          setRemaining(
+            next.truncated ? 0 : 100 - next.rows.length - next.unreadable,
+          );
+          setWarning(
+            [
+              next.unreadable
+                ? `${next.unreadable} saved configuration(s) could not be read. They may use a newer format or contain invalid data; other repositories remain editable.`
+                : "",
+              next.truncated
+                ? "Showing the first 100 configurations. Use another review channel for additional repositories."
+                : "",
+            ]
+              .filter(Boolean)
+              .join(" "),
+          );
+        }
+      })
+      .catch((reason: unknown) => {
+        if (!controller.signal.aborted)
+          setError(
+            reason instanceof Error
+              ? reason.message
+              : "Could not load configurations.",
+          );
+      })
+      .finally(() => {
+        if (!controller.signal.aborted) setLoading(false);
+      });
+    return () => controller.abort();
+  }, [session, channel, reload]);
+  return (
+    <>
+      <InlineHeader title="Repositories" />
+      <div className="review-config-actions">
+        <Button
+          disabled={loading || !!editor}
+          onClick={() => {
+            setNotice("");
+            setReload((value) => value + 1);
+          }}
+        >
+          Reload
+        </Button>
+        <Button
+          variant="prominent"
+          disabled={
+            loading || !!error || !!editor || !writable || remaining <= 0
+          }
+          onClick={(event) => {
+            editorTrigger.current = event.currentTarget;
+            setNotice("");
+            setEditor("new");
+          }}
+        >
+          Register repository
+        </Button>
+      </div>
+      {!session.configArtifactWriter && (
+        <p role="alert">
+          This connection cannot save settings. Reconnect with a supported Buzz
+          client.
+        </p>
+      )}
+      {!loading && !error && warning && <p role="alert">{warning}</p>}
+      {loading ? (
+        <p role="status">Loading configurations…</p>
+      ) : error ? (
+        <p role="alert">{error} Use Reload to try again.</p>
+      ) : rows.length ? (
+        <table className="review-config-table">
+          <caption className="sr-only">Saved repository configurations</caption>
+          <thead>
+            <tr>
+              <th scope="col">Repository</th>
+              <th scope="col">Lanes</th>
+              <th scope="col">Settings</th>
+            </tr>
+          </thead>
+          <tbody>
+            {rows.map((row) => (
+              <tr key={row.artifactId}>
+                <th scope="row">{row.config.repository}</th>
+                <td>{row.config.lanes.map((lane) => lane.name).join(", ")}</td>
+                <td>
+                  <Button
+                    aria-label={`Edit ${row.config.repository}`}
+                    disabled={!!editor || !writable}
+                    onClick={(event) => {
+                      editorTrigger.current = event.currentTarget;
+                      setNotice("");
+                      setEditor(row);
+                    }}
+                  >
+                    Edit
+                  </Button>
+                </td>
+              </tr>
+            ))}
+          </tbody>
+        </table>
+      ) : (
+        <p>
+          {warning
+            ? "No readable configurations in this channel."
+            : "No repositories configured in this channel. Register one to save its review lanes."}
+        </p>
+      )}
+      {notice && <p role="status">{notice}</p>}
+      {editor && (
+        <ConfigurationEditor
+          key={editor === "new" ? "new" : editor.revision}
+          session={session}
+          channel={channel}
+          writable={writable}
+          previous={editor === "new" ? undefined : editor}
+          existing={rows}
+          onCancel={() => setEditor(undefined)}
+          onSaved={(saved) => {
+            if (editor === "new") setRemaining((value) => value - 1);
+            setRows((current) =>
+              [
+                ...current.filter((row) => row.artifactId !== saved.artifactId),
+                saved,
+              ].sort((a, b) =>
+                a.config.repository.localeCompare(b.config.repository),
+              ),
+            );
+            setEditor(undefined);
+            setNotice(
+              `Saved ${saved.config.repository}. Reviews are not enabled yet.`,
+            );
+          }}
+        />
+      )}
+    </>
+  );
+}
+
+function ConfigurationEditor({
+  session,
+  channel,
+  writable,
+  previous,
+  existing,
+  onCancel,
+  onSaved,
+}: {
+  session: RelaySession;
+  channel: string;
+  writable: boolean;
+  previous: SavedReviewConfig | undefined;
+  existing: readonly SavedReviewConfig[];
+  onCancel: () => void;
+  onSaved: (saved: SavedReviewConfig) => void;
+}) {
+  const [draft, setDraft] = useState<ReviewConfig>(
+    () =>
+      previous?.config ?? {
+        version: 1,
+        repository: "",
+        reminderMinutes: 15,
+        lanes: [{ id: crypto.randomUUID(), name: "General", instructions: "" }],
+      },
+  );
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState("");
+  const operation = useRef<AbortController | undefined>(undefined);
+  useEffect(() => () => operation.current?.abort(), []);
+  async function save() {
+    if (operation.current || !writable) return;
+    const controller = new AbortController();
+    operation.current = controller;
+    setBusy(true);
+    setError("");
+    try {
+      if (
+        !previous &&
+        existing.some(
+          (row) => row.config.repository === repositoryName(draft.repository),
+        )
+      )
+        throw new Error(
+          "This repository is already configured in this channel. Cancel and edit its saved settings.",
+        );
+      const result = await saveConfiguration(
+        session,
+        channel,
+        draft,
+        previous,
+        AbortSignal.any([controller.signal, AbortSignal.timeout(20_000)]),
+      );
+      if (!controller.signal.aborted) onSaved(result);
+    } catch (reason) {
+      if (!controller.signal.aborted)
+        setError(
+          `${reason instanceof Error ? reason.message : "Could not save settings."} Your draft is still here. If settings changed elsewhere or the save timed out, copy your changes, then Cancel and Reload before retrying.`,
+        );
+    } finally {
+      operation.current = undefined;
+      if (!controller.signal.aborted) setBusy(false);
+    }
+  }
+  return (
+    <form
+      onSubmit={(event) => {
+        event.preventDefault();
+        void save();
+      }}
+      className="review-config-form"
+    >
+      <InlineHeader
+        title={previous ? "Edit repository" : "Register repository"}
+      />
+      <SettingsGroup layout="form">
+        <Field
+          label="GitHub repository"
+          description="Use owner/repository or the full repository URL."
+        >
+          <Input
+            autoFocus
+            required
+            value={draft.repository}
+            readOnly={!!previous}
+            disabled={busy}
+            maxLength={250}
+            placeholder="example-org/project"
+            onValueChange={(repository) => setDraft({ ...draft, repository })}
+          />
+        </Field>
+      </SettingsGroup>
+      {draft.lanes.map((lane, index) => (
+        <section key={lane.id} className="review-config-lane">
+          <div className="review-config-actions">
+            <InlineHeader title={`Lane ${index + 1}`} />
+            <Button
+              disabled={busy || draft.lanes.length === 1}
+              onClick={() =>
+                setDraft({
+                  ...draft,
+                  lanes: draft.lanes.filter((item) => item.id !== lane.id),
+                })
+              }
+            >
+              Remove lane {index + 1}
+            </Button>
+          </div>
+          <SettingsGroup layout="form">
+            <Field label={`Lane ${index + 1} name`}>
+              <Input
+                required
+                maxLength={80}
+                disabled={busy}
+                value={lane.name}
+                onValueChange={(name) =>
+                  setDraft({
+                    ...draft,
+                    lanes: draft.lanes.map((item) =>
+                      item.id === lane.id ? { ...item, name } : item,
+                    ),
+                  })
+                }
+              />
+            </Field>
+            <Field
+              label={`Lane ${index + 1} instructions`}
+              description="Save the instructions reviewers should receive for this lane."
+            >
+              <Textarea
+                required
+                rows={5}
+                maxLength={8000}
+                disabled={busy}
+                value={lane.instructions}
+                onChange={(event) =>
+                  setDraft({
+                    ...draft,
+                    lanes: draft.lanes.map((item) =>
+                      item.id === lane.id
+                        ? { ...item, instructions: event.target.value }
+                        : item,
+                    ),
+                  })
+                }
+              />
+            </Field>
+          </SettingsGroup>
+        </section>
+      ))}
+      <div>
+        <Button
+          disabled={busy || draft.lanes.length >= 12}
+          onClick={() =>
+            setDraft({
+              ...draft,
+              lanes: [
+                ...draft.lanes,
+                { id: crypto.randomUUID(), name: "", instructions: "" },
+              ],
+            })
+          }
+        >
+          Add lane
+        </Button>
+      </div>
+      <p>
+        Reminder interval: 15 minutes. Reviewer selection, routing, and reminder
+        delivery will be available in a later version.
+      </p>
+      {error && <p role="alert">{error}</p>}
+      <div className="review-config-actions">
+        <Button disabled={busy} onClick={onCancel}>
+          Cancel
+        </Button>
+        <Button
+          type="submit"
+          variant="prominent"
+          loading={busy}
+          disabled={!writable}
+        >
+          Save settings
+        </Button>
+      </div>
+    </form>
+  );
+}
diff --git a/src/bundled/review-configuration/configuration.test.ts b/src/bundled/review-configuration/configuration.test.ts
new file mode 100644
index 0000000000..5fcf705c65
--- /dev/null
+++ b/src/bundled/review-configuration/configuration.test.ts
@@ -0,0 +1,226 @@
+import { expect, it, vi } from "vitest";
+import type { RelaySession } from "../../features/relay/session";
+import type { EventData } from "../../features/relay/events";
+import type { EventTemplate } from "nostr-tools";
+import { keypair, signed } from "../../features/relay/testing";
+import {
+  loadConfigurations,
+  repositoryName,
+  saveConfiguration,
+  validateConfig,
+  type ReviewConfig,
+} from "./configuration";
+
+const channel = "11111111-1111-4111-8111-111111111111";
+const other = "22222222-2222-4222-8222-222222222222";
+const signal = () => AbortSignal.timeout(5000);
+const config: ReviewConfig = {
+  version: 1,
+  repository: "example-org/project",
+  reminderMinutes: 15,
+  lanes: [
+    {
+      id: "general",
+      name: "General",
+      instructions: "Check authorization and tests.",
+    },
+  ],
+};
+
+function host() {
+  const key = keypair();
+  let events: EventData[] = [];
+  const snapshotRead = vi.fn(async () => events);
+  const publish = vi.fn(async (event: EventData) => {
+    events = [event];
+    return event.id;
+  });
+  const sign = vi.fn(async (template: EventTemplate) => signed(key, template));
+  const session = {
+    snapshotRead,
+    configArtifactWriter: { sign, publish },
+  } as unknown as RelaySession;
+  return { session, snapshotRead, sign, publish };
+}
+
+it("creates and reloads a signed configuration, then updates the loaded revision", async () => {
+  const test = host();
+  const first = await saveConfiguration(
+    test.session,
+    channel,
+    config,
+    undefined,
+    signal(),
+  );
+  expect(test.publish.mock.calls[0]?.[0].tags).toContainEqual(["op", "create"]);
+  expect(test.publish.mock.calls[0]?.[0].tags).toContainEqual(["h", channel]);
+  expect(
+    (await loadConfigurations(test.session, channel, signal())).rows,
+  ).toEqual([first]);
+  expect(test.snapshotRead).toHaveBeenCalledWith(
+    [
+      {
+        kinds: [45010],
+        "#h": [channel],
+        "#type": ["buzz.review.config"],
+        artifact: "current",
+        limit: 101,
+      },
+    ],
+    expect.anything(),
+  );
+  const edited = {
+    ...config,
+    lanes: [
+      {
+        ...{ id: "general", name: "General", instructions: "" },
+        instructions: "Check keyboard navigation.",
+      },
+    ],
+  };
+  const second = await saveConfiguration(
+    test.session,
+    channel,
+    edited,
+    first,
+    signal(),
+  );
+  expect(test.publish.mock.calls[1]?.[0].tags).toContainEqual([
+    "prev",
+    first.revision,
+  ]);
+  expect(test.publish.mock.calls[1]?.[0].tags).toContainEqual(["op", "update"]);
+  expect(second.artifactId).toBe(first.artifactId);
+  expect(
+    (await loadConfigurations(test.session, channel, signal())).rows[0]?.config,
+  ).toEqual(edited);
+});
+
+it("never fetches a newer revision to overwrite a concurrent edit; propagates rejection", async () => {
+  const test = host();
+  const first = await saveConfiguration(
+    test.session,
+    channel,
+    config,
+    undefined,
+    signal(),
+  );
+  test.publish.mockRejectedValueOnce(
+    new Error("conflict: artifact head changed"),
+  );
+  await expect(
+    saveConfiguration(test.session, channel, config, first, signal()),
+  ).rejects.toThrow("head changed");
+  expect(test.snapshotRead).not.toHaveBeenCalled();
+  expect(test.publish.mock.calls[1]?.[0].tags).toContainEqual([
+    "prev",
+    first.revision,
+  ]);
+});
+
+it("canonicalizes duplicate repository inputs and scopes identities to the channel", async () => {
+  const test = host();
+  const first = await saveConfiguration(
+    test.session,
+    channel,
+    config,
+    undefined,
+    signal(),
+  );
+  const duplicate = await saveConfiguration(
+    test.session,
+    channel,
+    { ...config, repository: " https://github.com/Example-Org/PROJECT/ " },
+    undefined,
+    signal(),
+  );
+  expect(duplicate.artifactId).toBe(first.artifactId);
+  const separate = await saveConfiguration(
+    test.session,
+    other,
+    config,
+    undefined,
+    signal(),
+  );
+  expect(separate.artifactId).not.toBe(first.artifactId);
+  await expect(
+    saveConfiguration(test.session, other, config, first, signal()),
+  ).rejects.toThrow("new configuration");
+});
+
+it.each([
+  "https://github.com.evil.example/org/repo",
+  "https://user:password@github.com/org/repo",
+  "org/repo/pull/1",
+  "org/repo?token=secret",
+  "org/..",
+  "file:///tmp/project",
+])("refuses a non-repository input: %s", (input) => {
+  expect(() => repositoryName(input)).toThrow("GitHub repository");
+});
+
+it("validates stored settings and refuses unsupported versions, duplicate lanes and oversized payloads", () => {
+  expect(() => validateConfig({ ...config, version: 2 })).toThrow(
+    "Unsupported",
+  );
+  expect(() => validateConfig({ ...config, lanes: [] })).toThrow(
+    "between 1 and 12",
+  );
+  expect(() =>
+    validateConfig({
+      ...config,
+      lanes: [...config.lanes, { ...config.lanes[0], id: "second" }],
+    }),
+  ).toThrow("unique");
+  expect(() =>
+    validateConfig({
+      ...config,
+      lanes: [{ ...config.lanes[0], instructions: " " }],
+    }),
+  ).toThrow("instructions");
+  expect(() =>
+    validateConfig({
+      ...config,
+      lanes: [{ ...config.lanes[0], instructions: "😀".repeat(4000) }],
+    }),
+  ).not.toThrow();
+  expect(() =>
+    validateConfig({
+      ...config,
+      lanes: Array.from({ length: 3 }, (_, index) => ({
+        id: `lane-${index}`,
+        name: `Lane ${index}`,
+        instructions: "😀".repeat(4000),
+      })),
+    }),
+  ).toThrow("too large");
+});
+
+it("isolates unreadable rows and signals a truncated result", async () => {
+  const test = host();
+  await saveConfiguration(test.session, channel, config, undefined, signal());
+  const event = test.publish.mock.calls[0]?.[0];
+  if (!event) throw new Error("Expected a published configuration");
+  test.snapshotRead.mockResolvedValueOnce([
+    event,
+    { ...event, content: "{broken" },
+  ]);
+  const loaded = await loadConfigurations(test.session, channel, signal());
+  expect(loaded.rows).toHaveLength(1);
+  expect(loaded.unreadable).toBe(1);
+  test.snapshotRead.mockResolvedValueOnce([
+    {
+      ...event,
+      tags: event.tags.map((tag) => (tag[0] === "h" ? ["h", other] : tag)),
+    },
+  ]);
+  expect(
+    (await loadConfigurations(test.session, channel, signal())).unreadable,
+  ).toBe(1);
+  test.snapshotRead.mockResolvedValueOnce(
+    Array.from({ length: 101 }, () => event),
+  );
+  expect(
+    (await loadConfigurations(test.session, channel, signal())).truncated,
+  ).toBe(true);
+});
diff --git a/src/bundled/review-configuration/configuration.ts b/src/bundled/review-configuration/configuration.ts
new file mode 100644
index 0000000000..7e7b776212
--- /dev/null
+++ b/src/bundled/review-configuration/configuration.ts
@@ -0,0 +1,196 @@
+import {
+  ARTIFACT_KIND,
+  uuidv5,
+} from "../../features/agents/agent-config-artifacts";
+import type { EventData } from "../../features/relay/events";
+import type { RelaySession } from "../../features/relay/session";
+
+export const REVIEW_CONFIG_TYPE = "buzz.review.config";
+export type ReviewLane = Readonly<{
+  id: string;
+  name: string;
+  instructions: string;
+}>;
+export type ReviewConfig = Readonly<{
+  version: 1;
+  repository: string;
+  lanes: readonly ReviewLane[];
+  reminderMinutes: 15;
+}>;
+export type SavedReviewConfig = Readonly<{
+  config: ReviewConfig;
+  revision: string;
+  artifactId: string;
+}>;
+
+/** Canonical GitHub repository identity; credentials and non-repository URLs are refused. */
+export function repositoryName(input: string): string {
+  const value = input
+    .trim()
+    .replace(/^https:\/\/github\.com\//i, "")
+    .replace(/\/$/, "");
+  if (
+    !/^[a-z\d](?:[a-z\d-]{0,38})\/[a-z\d_.-]{1,100}$/i.test(value) ||
+    /\/(?:\.|\.\.)$/.test(value)
+  )
+    throw new Error(
+      "Enter a GitHub repository as owner/repository or its https://github.com URL.",
+    );
+  return value.toLowerCase();
+}
+
+/** Validate both form drafts and untrusted stored content. */
+export function validateConfig(value: unknown): ReviewConfig {
+  if (!value || typeof value !== "object")
+    throw new Error("Invalid review configuration.");
+  const item = value as Partial<ReviewConfig>;
+  if (
+    item.version !== 1 ||
+    item.reminderMinutes !== 15 ||
+    typeof item.repository !== "string"
+  )
+    throw new Error("Unsupported review configuration version or settings.");
+  if (
+    !Array.isArray(item.lanes) ||
+    item.lanes.length < 1 ||
+    item.lanes.length > 12
+  )
+    throw new Error("Configure between 1 and 12 review lanes.");
+  const ids = new Set<string>();
+  const names = new Set<string>();
+  const lanes = item.lanes.map((lane: ReviewLane) => {
+    if (
+      !lane ||
+      typeof lane.id !== "string" ||
+      !/^[a-z\d-]{1,64}$/i.test(lane.id) ||
+      typeof lane.name !== "string" ||
+      !lane.name.trim() ||
+      lane.name.trim().length > 80 ||
+      typeof lane.instructions !== "string" ||
+      !lane.instructions.trim() ||
+      lane.instructions.length > 8000
+    )
+      throw new Error(
+        "Each lane needs a name (up to 80 characters) and instructions (up to 8,000 characters).",
+      );
+    const name = lane.name.trim();
+    if (ids.has(lane.id) || names.has(name.toLowerCase()))
+      throw new Error("Lane names must be unique.");
+    ids.add(lane.id);
+    names.add(name.toLowerCase());
+    return { id: lane.id, name, instructions: lane.instructions.trim() };
+  });
+  const config: ReviewConfig = {
+    version: 1,
+    repository: repositoryName(item.repository),
+    lanes,
+    reminderMinutes: 15,
+  };
+  if (new TextEncoder().encode(JSON.stringify(config)).length > 32_000)
+    throw new Error(
+      "This configuration is too large. Shorten the lane instructions.",
+    );
+  return config;
+}
+
+const tag = (event: EventData, name: string) =>
+  event.tags.find((item) => item[0] === name)?.[1];
+const identity = (channel: string, repository: string) =>
+  uuidv5(channel, `${REVIEW_CONFIG_TYPE}:${repository}`);
+
+/** One bounded read when the user opens or reloads a channel; never a polling loop. */
+export async function loadConfigurations(
+  session: RelaySession,
+  channel: string,
+  signal: AbortSignal,
+): Promise<{
+  rows: SavedReviewConfig[];
+  unreadable: number;
+  truncated: boolean;
+}> {
+  if (!session.snapshotRead)
+    throw new Error("This connection cannot read review configuration.");
+  const events = await session.snapshotRead(
+    [
+      {
+        kinds: [ARTIFACT_KIND],
+        "#h": [channel],
+        "#type": [REVIEW_CONFIG_TYPE],
+        artifact: "current",
+        limit: 101,
+      },
+    ],
+    { signal },
+  );
+  const results = await Promise.allSettled(
+    events.slice(0, 100).map(async (event) => {
+      if (
+        event.kind !== ARTIFACT_KIND ||
+        tag(event, "h") !== channel ||
+        tag(event, "type") !== REVIEW_CONFIG_TYPE
+      )
+        throw new Error(
+          "The relay returned an unexpected review configuration.",
+        );
+      const config = validateConfig(JSON.parse(event.content));
+      const artifactId = await identity(channel, config.repository);
+      if (tag(event, "d") !== artifactId)
+        throw new Error(
+          "A saved configuration has an invalid repository identity.",
+        );
+      return { config, revision: event.id, artifactId };
+    }),
+  );
+  const rows = results.flatMap((result) =>
+    result.status === "fulfilled" ? [result.value] : [],
+  );
+  return {
+    rows: rows.sort((a, b) =>
+      a.config.repository.localeCompare(b.config.repository),
+    ),
+    unreadable: results.filter((result) => result.status === "rejected").length,
+    truncated: events.length > 100,
+  };
+}
+
+/** Save against the revision the editor loaded, so concurrent edits cannot be overwritten. */
+export async function saveConfiguration(
+  session: RelaySession,
+  channel: string,
+  draft: ReviewConfig,
+  previous: SavedReviewConfig | undefined,
+  signal: AbortSignal,
+): Promise<SavedReviewConfig> {
+  const writer = session.configArtifactWriter;
+  if (!writer)
+    throw new Error("This connection cannot save review configuration.");
+  const config = validateConfig(draft);
+  const artifactId = await identity(channel, config.repository);
+  if (
+    previous &&
+    (previous.artifactId !== artifactId ||
+      previous.config.repository !== config.repository)
+  )
+    throw new Error(
+      "Create a new configuration to change the repository or channel.",
+    );
+  const event = await writer.sign(
+    {
+      kind: ARTIFACT_KIND,
+      created_at: Math.floor(Date.now() / 1000),
+      content: JSON.stringify(config),
+      tags: [
+        ["ar", "1"],
+        ["d", artifactId],
+        ["h", channel],
+        ["type", REVIEW_CONFIG_TYPE],
+        ["title", `Review configuration: ${config.repository}`],
+        ["op", previous ? "update" : "create"],
+        ...(previous ? [["prev", previous.revision]] : []),
+      ],
+    },
+    signal,
+  );
+  await writer.publish(event, signal);
+  return { config, artifactId, revision: event.id };
+}
diff --git a/src/bundled/review-configuration/index.tsx b/src/bundled/review-configuration/index.tsx
new file mode 100644
index 0000000000..e557e443d2
--- /dev/null
+++ b/src/bundled/review-configuration/index.tsx
@@ -0,0 +1,15 @@
+import type { PluginModule } from "../../plugins/api";
+import { ReviewConfigurationPage } from "./ReviewConfigurationPage";
+
+export const inject = ["pages", "relay"];
+export const apply: PluginModule["apply"] = (ctx) => {
+  const relay = ctx.relay;
+  ctx.pages.register({
+    id: "configuration",
+    title: "Review Configuration",
+    layout: "workspace",
+    primary: true,
+    placement: "sidebar",
+    component: () => <ReviewConfigurationPage relay={relay} />,
+  });
+};
diff --git a/src/bundled/review-configuration/manifest.json b/src/bundled/review-configuration/manifest.json
new file mode 100644
index 0000000000..1deac77fd8
--- /dev/null
+++ b/src/bundled/review-configuration/manifest.json
@@ -0,0 +1,7 @@
+{
+  "id": "buzz.review-configuration",
+  "name": "Review Configuration",
+  "apiVersion": 1,
+  "description": "Save repository and lane settings for review workflows.",
+  "discovery": { "category": "productivity", "tags": ["reviews"] }
+}
diff --git a/src/bundled/review-configuration/review-configuration.css b/src/bundled/review-configuration/review-configuration.css
new file mode 100644
index 0000000000..5f72f4393e
--- /dev/null
+++ b/src/bundled/review-configuration/review-configuration.css
@@ -0,0 +1,44 @@
+.review-config-page {
+  display: flex;
+  flex-direction: column;
+  height: 100%;
+  min-height: 0;
+}
+.review-config-scroll {
+  flex: 1;
+  min-height: 0;
+  overflow: auto;
+  padding: var(--space-4) var(--space-panel-inset) var(--space-8);
+}
+.review-config-content {
+  max-width: 48rem;
+  margin-inline: auto;
+}
+.review-config-content,
+.review-config-form,
+.review-config-lane {
+  display: flex;
+  flex-direction: column;
+  gap: var(--space-4);
+  min-width: 0;
+}
+.review-config-content p {
+  margin: 0;
+}
+.review-config-actions {
+  display: flex;
+  flex-wrap: wrap;
+  gap: var(--space-2);
+}
+.review-config-table {
+  width: 100%;
+  table-layout: fixed;
+  border-collapse: collapse;
+}
+.review-config-table th,
+.review-config-table td {
+  text-align: start;
+  overflow-wrap: anywhere;
+  padding: var(--space-2);
+  border-bottom: 1px solid var(--border-standard);
+}

From fe42ff8c60a3939a1cea80230fda5994dc07b5e2 Mon Sep 17 00:00:00 2001
From: Ravneet Arora <rarora@squareup.com>
Date: Wed, 11 Nov 2026 12:49:52 -0500
Subject: [PATCH 02/17] Save reviewer agents with each review lane

Use the shared agent inventory and keep unavailable selections visible.
Expose refresh and partial discovery errors so users can recover.

Co-authored-by: maincourse <37ce551b493d4a998caf030929c47bce0b6a0e43f1178b3a63c4151d7c16b76e@buzz.block.builderlab.xyz>
Signed-off-by: Ravneet Arora <rarora@squareup.com>
---
 docs/buzz-help.md                             |   7 +-
 src/app/pages.integration.test.mjs            |  29 +++++
 .../review-configuration/LaneReviewers.tsx    |  72 +++++++++++
 src/bundled/review-configuration/README.md    |  23 +++-
 .../ReviewConfigurationPage.test.tsx          | 115 ++++++++++++++++++
 .../ReviewConfigurationPage.tsx               |  87 ++++++++++++-
 .../configuration.test.ts                     |  26 +++-
 .../review-configuration/configuration.ts     |  19 ++-
 .../review-configuration/manifest.json        |   2 +-
 .../review-configuration.css                  |   7 +-
 10 files changed, 371 insertions(+), 16 deletions(-)
 create mode 100644 src/bundled/review-configuration/LaneReviewers.tsx

diff --git a/docs/buzz-help.md b/docs/buzz-help.md
index 7899199002..0ae02dbafc 100644
--- a/docs/buzz-help.md
+++ b/docs/buzz-help.md
@@ -1155,13 +1155,14 @@ confirmation. **Delete team** asks first; it doesn't delete the team's agents.
   choices persist. A deliberate plugin-settings reset uses the current defaults.
 - **Review Configuration** is optional and starts off. Enable it in **Manage
   plugins** to add its own Messages sidebar entry. Choose a review channel,
-  register a GitHub repository, and save named lanes with instructions. Saved
+  register a GitHub repository, and save named lanes with reviewer agents and
+  instructions. Each lane supports multiple reviewers. Saved
   repositories appear in a table; **Edit** changes their settings and **Reload**
   reads the latest saved versions. Settings live on the community relay and are
   visible to channel readers; members who can post can edit them. A conflicting
   edit preserves your draft: copy your changes before cancelling and reloading.
-  This first version saves configuration only. It does not assign reviewers,
-  submit PRs, or send the planned 15-minute reminders.
+  This first version saves configuration and reviewer selections only. It does not
+  dispatch reviews, submit PRs, or send the planned 15-minute reminders.
 - A plugin's details in Manage plugins link to the Settings sections that hold
   its settings: sections it adds, such as GitHub comment authors, and Decisions
   API for a decision provider, such as TypeSafe. Only sections the Settings
diff --git a/src/app/pages.integration.test.mjs b/src/app/pages.integration.test.mjs
index e3626f08e3..4a218b5b7c 100644
--- a/src/app/pages.integration.test.mjs
+++ b/src/app/pages.integration.test.mjs
@@ -94,6 +94,7 @@ test("the app runtime exposes ready bundled pages and removes them on disable",
           "buzz.focus",
           "buzz.charts",
           "buzz.drafts-and-sent",
+          "buzz.review-configuration",
         ].includes(plugin.manifest.id),
         plugin.manifest.id,
       );
@@ -102,12 +103,40 @@ test("the app runtime exposes ready bundled pages and removes them on disable",
       "buzz.reminders",
       "buzz.workflows",
       "buzz.drafts-and-sent",
+      "buzz.review-configuration",
     ]) {
       assert.equal(
         services.pages.snapshot().some((page) => page.pluginId === id),
         false,
       );
     }
+    await services.plugins.change("enable", "buzz.review-configuration");
+    await vi.waitFor(() =>
+      assert.ok(
+        services.pages
+          .snapshot()
+          .some(
+            (page) => page.key === "buzz.review-configuration/configuration",
+          ),
+      ),
+    );
+    const reviewConfiguration = services.pages
+      .snapshot()
+      .find((page) => page.pluginId === "buzz.review-configuration");
+    assert.equal(reviewConfiguration.title, "Review Configuration");
+    assert.equal(reviewConfiguration.primary, true);
+    assert.equal(reviewConfiguration.placement, "sidebar");
+    assert.match(
+      renderToStaticMarkup(createElement(reviewConfiguration.component)),
+      /Connect to a community to configure reviews/,
+    );
+    await services.plugins.change("disable", "buzz.review-configuration");
+    assert.equal(
+      services.pages
+        .snapshot()
+        .some((page) => page.pluginId === "buzz.review-configuration"),
+      false,
+    );
     await services.plugins.change("enable", "buzz.reminders");
     await vi.waitFor(() =>
       assert.ok(
diff --git a/src/bundled/review-configuration/LaneReviewers.tsx b/src/bundled/review-configuration/LaneReviewers.tsx
new file mode 100644
index 0000000000..f1dcd53e7a
--- /dev/null
+++ b/src/bundled/review-configuration/LaneReviewers.tsx
@@ -0,0 +1,72 @@
+import type { AgentChoicesSnapshot } from "../../features/agents/choices";
+import { Button } from "../../shared/design-system/ui/Button";
+import { Select } from "../../shared/design-system/ui/Select";
+
+/** Selection records identities only; it grants no channel access or execution authority. */
+export function LaneReviewers({
+  lane,
+  reviewers,
+  choices,
+  disabled,
+  onChange,
+}: {
+  lane: number;
+  reviewers: readonly string[];
+  choices: AgentChoicesSnapshot;
+  disabled: boolean;
+  onChange: (reviewers: readonly string[]) => void;
+}) {
+  const available = choices.selectable.filter(
+    (agent) => !reviewers.includes(agent.pubkey),
+  );
+  return (
+    <div className="review-config-reviewers">
+      <Select
+        label={`Lane ${lane} reviewers`}
+        variant="field"
+        value=""
+        placeholder="Add reviewer…"
+        disabled={disabled || reviewers.length >= 20 || available.length === 0}
+        groups={[
+          {
+            label: "Agents",
+            options: available.map((agent) => ({
+              value: agent.pubkey,
+              label: `${agent.managedName ?? agent.name} (${agent.pubkey.slice(0, 8)})`,
+            })),
+          },
+        ]}
+        onValueChange={(pubkey) => {
+          if (available.some((agent) => agent.pubkey === pubkey))
+            onChange([...reviewers, pubkey]);
+        }}
+        description="Choose one or more reviewers. The same agent can be assigned to several lanes."
+      />
+      {reviewers.length === 0 && <p>No reviewers assigned.</p>}
+      {reviewers.map((pubkey) => {
+        const agent = choices.identities.find((item) => item.pubkey === pubkey);
+        const name = agent?.managedName ?? agent?.name ?? pubkey;
+        const selectable = choices.selectable.some(
+          (item) => item.pubkey === pubkey,
+        );
+        return (
+          <div key={pubkey} className="review-config-actions">
+            <span title={pubkey}>
+              {name}
+              {!selectable ? " — unavailable in this session" : ""}
+            </span>
+            <Button
+              disabled={disabled}
+              aria-label={`Remove ${name} from lane ${lane}`}
+              onClick={() =>
+                onChange(reviewers.filter((key) => key !== pubkey))
+              }
+            >
+              Remove
+            </Button>
+          </div>
+        );
+      })}
+    </div>
+  );
+}
diff --git a/src/bundled/review-configuration/README.md b/src/bundled/review-configuration/README.md
index 933723e31c..5ff546e41c 100644
--- a/src/bundled/review-configuration/README.md
+++ b/src/bundled/review-configuration/README.md
@@ -2,12 +2,21 @@
 
 An optional bundled plugin with a separate sidebar page for repository review
 settings. Enable **Review Configuration** in Settings → Plugins → Manage plugins.
-Choose a channel, register a GitHub repository, add named lanes and instructions,
+Choose a channel, register a GitHub repository, add named lanes, reviewer agents, and instructions,
 and save. The repository table supports editing and an explicit reload.
 
-This is configuration only. It does not submit PRs, choose reviewers, create
+This is configuration only. It does not submit PRs, dispatch reviewers, create
 review threads, or send reminders. No agent or timer runs in the background.
 
+## Getting started
+
+Enable this plugin in **Settings → Plugins → Manage plugins**, then open its
+sidebar entry. Choose a channel and register a repository. For each lane, select
+reviewer agents and enter instructions, then save. Use the table to edit settings.
+These selections do not start reviews or grant agents access to the channel.
+
+---
+
 ## Storage and access
 
 `configuration.ts` owns the save/load boundary. Each channel/repository pair has
@@ -22,7 +31,8 @@ The signed event's `h` tag is its review channel. Its content is:
     {
       "id": "general",
       "name": "General",
-      "instructions": "Check authorization, error handling, and tests."
+      "instructions": "Check authorization, error handling, and tests.",
+      "reviewers": []
     }
   ],
   "reminderMinutes": 15
@@ -53,10 +63,15 @@ The reminder interval is saved for the planned executor but has no effect yet.
 
 1. Enable the plugin and open **Review Configuration** in the Messages sidebar.
 2. Choose a writable stream or forum channel and click **Register repository**.
-3. Enter a repository and lane instructions, then **Save settings**.
+3. Enter a repository, select lane reviewers, add instructions, then **Save settings**.
 4. Reload the page, choose the same channel, and verify the repository row.
 5. Edit the instructions, save, and use **Reload** to confirm the new version.
 6. In two clients, edit the same version; the second save must fail without
    discarding its draft after the first client saves.
 
 Use a test channel. Saving does not activate any review automation.
+
+Reviewer choices come from the session’s shared agent inventory. Saved public keys
+remain visible and removable if an agent disappears or is archived. Unassigned
+lanes may be saved as drafts. Dispatch must check agent ownership and channel
+access when execution is implemented.
diff --git a/src/bundled/review-configuration/ReviewConfigurationPage.test.tsx b/src/bundled/review-configuration/ReviewConfigurationPage.test.tsx
index 2e7b961126..0a1c86dabb 100644
--- a/src/bundled/review-configuration/ReviewConfigurationPage.test.tsx
+++ b/src/bundled/review-configuration/ReviewConfigurationPage.test.tsx
@@ -21,12 +21,48 @@ function fixture() {
     ],
   };
   const listeners = new Set<() => void>();
+  const agents = [
+    { pubkey: "a".repeat(64), name: "Backend reviewer", managed: true },
+    { pubkey: "b".repeat(64), name: "UI reviewer", managed: true },
+  ];
+  let choices = {
+    error: undefined as string | undefined,
+    status: "ready",
+    pending: false,
+    complete: true,
+    identities: agents,
+    selectable: agents,
+    archives: {
+      status: "ready",
+      archived: [],
+      error: undefined as string | undefined,
+    },
+    definitions: [],
+  };
   const snapshotRead = vi.fn(async () => events);
   const publish = vi.fn(async (event: EventData) => {
     events = [event];
     return event.id;
   });
   const session = {
+    agentChoices: {
+      snapshot: () => choices,
+      subscribe: (listener: () => void) => {
+        listeners.add(listener);
+        return () => listeners.delete(listener);
+      },
+      ensure() {},
+      refresh: vi.fn(async () => {
+        choices = {
+          ...choices,
+          error: undefined,
+          selectable: agents,
+          archives: { ...choices.archives, error: undefined },
+        };
+        for (const listener of listeners) listener();
+      }),
+      retain: () => () => {},
+    },
     channels: {
       ensureList() {},
       list: () => list,
@@ -45,6 +81,19 @@ function fixture() {
     session,
     publish,
     snapshotRead,
+    failAgents() {
+      choices = {
+        ...choices,
+        error: "Inventory unavailable",
+        selectable: [],
+        archives: { ...choices.archives, error: "Archive read failed" },
+      };
+      for (const listener of listeners) listener();
+    },
+    hideAgents() {
+      choices = { ...choices, selectable: [] };
+      for (const listener of listeners) listener();
+    },
     metadataCached(cached: boolean) {
       list = {
         ...list,
@@ -246,3 +295,69 @@ it("counts unreadable records toward the limit when a new repository is saved",
     ).disabled,
   ).toBe(true);
 });
+
+it("saves multiple lane reviewers, reloads their identities, and preserves unavailable selections", async () => {
+  const test = fixture();
+  render(<ReviewConfigurationCommunity session={test.session} />);
+  const user = await openDraft();
+  await user.click(screen.getByRole("combobox", { name: "Lane 1 reviewers" }));
+  await user.click(
+    await screen.findByRole("option", { name: "Backend reviewer (aaaaaaaa)" }),
+  );
+  await user.click(screen.getByRole("combobox", { name: "Lane 1 reviewers" }));
+  await user.click(
+    await screen.findByRole("option", { name: "UI reviewer (bbbbbbbb)" }),
+  );
+  await user.click(screen.getByRole("button", { name: "Save settings" }));
+  await screen.findByText(
+    "Saved example-org/project. Reviews are not enabled yet.",
+  );
+  const content = test.publish.mock.calls[0]?.[0].content;
+  expect(JSON.parse(content ?? "{}").lanes[0].reviewers).toEqual([
+    "a".repeat(64),
+    "b".repeat(64),
+  ]);
+  await user.click(screen.getByRole("button", { name: "Reload" }));
+  await user.click(
+    await screen.findByRole("button", { name: "Edit example-org/project" }),
+  );
+  await screen.findByRole("button", {
+    name: "Remove Backend reviewer from lane 1",
+  });
+  act(() => test.hideAgents());
+  await screen.findByText("Backend reviewer — unavailable in this session");
+  await user.click(
+    screen.getByRole("button", { name: "Remove Backend reviewer from lane 1" }),
+  );
+  await user.click(screen.getByRole("button", { name: "Save settings" }));
+  await screen.findByText(
+    "Saved example-org/project. Reviews are not enabled yet.",
+  );
+  expect(
+    JSON.parse(test.publish.mock.calls[1]?.[0].content ?? "{}").lanes[0]
+      .reviewers,
+  ).toEqual(["b".repeat(64)]);
+});
+
+it("refreshes failed agent and archive reads without discarding the draft", async () => {
+  const test = fixture();
+  test.failAgents();
+  render(<ReviewConfigurationCommunity session={test.session} />);
+  const user = await openDraft();
+  expect(screen.getByText(/Inventory unavailable/)).toBeTruthy();
+  expect(screen.getByText(/Archive read failed/)).toBeTruthy();
+  await user.click(screen.getByRole("button", { name: "Refresh agents" }));
+  expect(test.session.agentChoices.refresh).toHaveBeenCalledWith(true);
+  await user.click(screen.getByRole("combobox", { name: "Lane 1 reviewers" }));
+  await user.click(
+    await screen.findByRole("option", { name: "Backend reviewer (aaaaaaaa)" }),
+  );
+  await user.click(screen.getByRole("button", { name: "Save settings" }));
+  await screen.findByText(
+    "Saved example-org/project. Reviews are not enabled yet.",
+  );
+  expect(
+    JSON.parse(test.publish.mock.calls[0]?.[0].content ?? "null").lanes[0]
+      .reviewers,
+  ).toEqual(["a".repeat(64)]);
+});
diff --git a/src/bundled/review-configuration/ReviewConfigurationPage.tsx b/src/bundled/review-configuration/ReviewConfigurationPage.tsx
index cd1fbc4718..97352cc2c8 100644
--- a/src/bundled/review-configuration/ReviewConfigurationPage.tsx
+++ b/src/bundled/review-configuration/ReviewConfigurationPage.tsx
@@ -1,4 +1,6 @@
 import { useEffect, useRef, useState, type ReactNode } from "react";
+import { useAgentChoices } from "../../features/agents/use-choices";
+import { LaneReviewers } from "./LaneReviewers";
 import { useChannelList, useRelayConnection } from "../../features/relay/react";
 import type { RelayData } from "../../features/relay/service";
 import type { RelaySession } from "../../features/relay/session";
@@ -260,7 +262,14 @@ function ChannelConfiguration({
             {rows.map((row) => (
               <tr key={row.artifactId}>
                 <th scope="row">{row.config.repository}</th>
-                <td>{row.config.lanes.map((lane) => lane.name).join(", ")}</td>
+                <td>
+                  {row.config.lanes
+                    .map(
+                      (lane) =>
+                        `${lane.name} (${lane.reviewers.length} ${lane.reviewers.length === 1 ? "reviewer" : "reviewers"})`,
+                    )
+                    .join(", ")}
+                </td>
                 <td>
                   <Button
                     aria-label={`Edit ${row.config.repository}`}
@@ -333,13 +342,23 @@ function ConfigurationEditor({
   onCancel: () => void;
   onSaved: (saved: SavedReviewConfig) => void;
 }) {
+  const choices = useAgentChoices(session, true, true);
+  const [refreshingAgents, setRefreshingAgents] = useState(false);
+  const [agentRefreshError, setAgentRefreshError] = useState("");
   const [draft, setDraft] = useState<ReviewConfig>(
     () =>
       previous?.config ?? {
         version: 1,
         repository: "",
         reminderMinutes: 15,
-        lanes: [{ id: crypto.randomUUID(), name: "General", instructions: "" }],
+        lanes: [
+          {
+            id: crypto.randomUUID(),
+            name: "General",
+            instructions: "",
+            reviewers: [],
+          },
+        ],
       },
   );
   const [busy, setBusy] = useState(false);
@@ -408,6 +427,45 @@ function ConfigurationEditor({
           />
         </Field>
       </SettingsGroup>
+      {choices.pending && <p role="status">Loading reviewer agents…</p>}
+      {!choices.pending && !choices.selectable.length && (
+        <p>
+          No reviewer agents are available in this session. Create or connect an
+          agent in Agents, then refresh this list.
+        </p>
+      )}
+      {choices.error && (
+        <p role="alert">Some agents could not be loaded: {choices.error}</p>
+      )}
+      {choices.archives.error && (
+        <p role="alert">
+          Archived agents could not be checked: {choices.archives.error}
+        </p>
+      )}
+      {agentRefreshError && <p role="alert">{agentRefreshError}</p>}
+      <div>
+        <Button
+          disabled={busy || refreshingAgents}
+          loading={refreshingAgents}
+          onClick={async () => {
+            setRefreshingAgents(true);
+            setAgentRefreshError("");
+            try {
+              await session.agentChoices.refresh(true);
+            } catch (reason) {
+              setAgentRefreshError(
+                reason instanceof Error
+                  ? reason.message
+                  : "Could not refresh agents.",
+              );
+            } finally {
+              setRefreshingAgents(false);
+            }
+          }}
+        >
+          Refresh agents
+        </Button>
+      </div>
       {draft.lanes.map((lane, index) => (
         <section key={lane.id} className="review-config-lane">
           <div className="review-config-actions">
@@ -441,6 +499,20 @@ function ConfigurationEditor({
                 }
               />
             </Field>
+            <LaneReviewers
+              lane={index + 1}
+              reviewers={lane.reviewers}
+              choices={choices}
+              disabled={busy}
+              onChange={(reviewers) =>
+                setDraft({
+                  ...draft,
+                  lanes: draft.lanes.map((item) =>
+                    item.id === lane.id ? { ...item, reviewers } : item,
+                  ),
+                })
+              }
+            />
             <Field
               label={`Lane ${index + 1} instructions`}
               description="Save the instructions reviewers should receive for this lane."
@@ -474,7 +546,12 @@ function ConfigurationEditor({
               ...draft,
               lanes: [
                 ...draft.lanes,
-                { id: crypto.randomUUID(), name: "", instructions: "" },
+                {
+                  id: crypto.randomUUID(),
+                  name: "",
+                  instructions: "",
+                  reviewers: [],
+                },
               ],
             })
           }
@@ -483,8 +560,8 @@ function ConfigurationEditor({
         </Button>
       </div>
       <p>
-        Reminder interval: 15 minutes. Reviewer selection, routing, and reminder
-        delivery will be available in a later version.
+        Reminder interval: 15 minutes. Routing and reminder delivery will be
+        available in a later version.
       </p>
       {error && <p role="alert">{error}</p>}
       <div className="review-config-actions">
diff --git a/src/bundled/review-configuration/configuration.test.ts b/src/bundled/review-configuration/configuration.test.ts
index 5fcf705c65..caa19259f0 100644
--- a/src/bundled/review-configuration/configuration.test.ts
+++ b/src/bundled/review-configuration/configuration.test.ts
@@ -23,6 +23,7 @@ const config: ReviewConfig = {
       id: "general",
       name: "General",
       instructions: "Check authorization and tests.",
+      reviewers: ["a".repeat(64)],
     },
   ],
 };
@@ -73,7 +74,7 @@ it("creates and reloads a signed configuration, then updates the loaded revision
     ...config,
     lanes: [
       {
-        ...{ id: "general", name: "General", instructions: "" },
+        ...{ id: "general", name: "General", instructions: "", reviewers: [] },
         instructions: "Check keyboard navigation.",
       },
     ],
@@ -224,3 +225,26 @@ it("isolates unreadable rows and signals a truncated result", async () => {
     (await loadConfigurations(test.session, channel, signal())).truncated,
   ).toBe(true);
 });
+
+it("validates reviewer identities and reads earlier drafts without reviewers", () => {
+  expect(() =>
+    validateConfig({
+      ...config,
+      lanes: [{ ...config.lanes[0], reviewers: ["not-a-key"] }],
+    }),
+  ).toThrow("reviewer agents");
+  expect(() =>
+    validateConfig({
+      ...config,
+      lanes: [
+        { ...config.lanes[0], reviewers: ["a".repeat(64), "a".repeat(64)] },
+      ],
+    }),
+  ).toThrow("distinct");
+  expect(
+    validateConfig({
+      ...config,
+      lanes: [{ ...config.lanes[0], reviewers: undefined }],
+    }).lanes[0]?.reviewers,
+  ).toEqual([]);
+});
diff --git a/src/bundled/review-configuration/configuration.ts b/src/bundled/review-configuration/configuration.ts
index 7e7b776212..dd2e23fbf5 100644
--- a/src/bundled/review-configuration/configuration.ts
+++ b/src/bundled/review-configuration/configuration.ts
@@ -10,6 +10,7 @@ export type ReviewLane = Readonly<{
   id: string;
   name: string;
   instructions: string;
+  reviewers: readonly string[];
 }>;
 export type ReviewConfig = Readonly<{
   version: 1;
@@ -78,7 +79,23 @@ export function validateConfig(value: unknown): ReviewConfig {
       throw new Error("Lane names must be unique.");
     ids.add(lane.id);
     names.add(name.toLowerCase());
-    return { id: lane.id, name, instructions: lane.instructions.trim() };
+    // Early draft configurations may not yet have reviewer selections.
+    const reviewers: unknown = lane.reviewers ?? [];
+    if (
+      !Array.isArray(reviewers) ||
+      reviewers.length > 20 ||
+      reviewers.some(
+        (key) => typeof key !== "string" || !/^[0-9a-f]{64}$/.test(key),
+      ) ||
+      new Set(reviewers).size !== reviewers.length
+    )
+      throw new Error("Choose up to 20 distinct reviewer agents per lane.");
+    return {
+      id: lane.id,
+      name,
+      instructions: lane.instructions.trim(),
+      reviewers: reviewers as string[],
+    };
   });
   const config: ReviewConfig = {
     version: 1,
diff --git a/src/bundled/review-configuration/manifest.json b/src/bundled/review-configuration/manifest.json
index 1deac77fd8..26d514abfe 100644
--- a/src/bundled/review-configuration/manifest.json
+++ b/src/bundled/review-configuration/manifest.json
@@ -3,5 +3,5 @@
   "name": "Review Configuration",
   "apiVersion": 1,
   "description": "Save repository and lane settings for review workflows.",
-  "discovery": { "category": "productivity", "tags": ["reviews"] }
+  "discovery": { "category": "productivity", "tags": ["code", "tasks"] }
 }
diff --git a/src/bundled/review-configuration/review-configuration.css b/src/bundled/review-configuration/review-configuration.css
index 5f72f4393e..b12b427ebe 100644
--- a/src/bundled/review-configuration/review-configuration.css
+++ b/src/bundled/review-configuration/review-configuration.css
@@ -16,7 +16,8 @@
 }
 .review-config-content,
 .review-config-form,
-.review-config-lane {
+.review-config-lane,
+.review-config-reviewers {
   display: flex;
   flex-direction: column;
   gap: var(--space-4);
@@ -25,6 +26,10 @@
 .review-config-content p {
   margin: 0;
 }
+.review-config-reviewers span {
+  overflow-wrap: anywhere;
+  min-width: 0;
+}
 .review-config-actions {
   display: flex;
   flex-wrap: wrap;

From b0bde7ee29f57cd933852f6ad69560b03925b3ea Mon Sep 17 00:00:00 2001
From: Ravneet Arora <rarora@squareup.com>
Date: Thu, 12 Nov 2026 11:30:26 -0500
Subject: [PATCH 03/17] Submit PRs to saved review lanes

Persist reviewer instruction snapshots and thread links. Recover interrupted delivery through the existing outbox without creating duplicate review threads.

Co-authored-by: maincourse <37ce551b493d4a998caf030929c47bce0b6a0e43f1178b3a63c4151d7c16b76e@buzz.block.builderlab.xyz>
Signed-off-by: Ravneet Arora <rarora@squareup.com>
---
 docs/buzz-help.md                             |  11 +-
 src/bundled/review-configuration/README.md    |  50 +-
 .../ReviewConfigurationPage.test.tsx          |  16 +-
 .../ReviewConfigurationPage.tsx               |  63 ++-
 .../ReviewSubmissions.test.tsx                |  70 +++
 .../ReviewSubmissions.tsx                     | 406 ++++++++++++++
 src/bundled/review-configuration/index.tsx    |   8 +-
 .../review-configuration.css                  |   5 +
 .../review-configuration/submissions.test.ts  | 363 ++++++++++++
 .../review-configuration/submissions.ts       | 515 ++++++++++++++++++
 10 files changed, 1481 insertions(+), 26 deletions(-)
 create mode 100644 src/bundled/review-configuration/ReviewSubmissions.test.tsx
 create mode 100644 src/bundled/review-configuration/ReviewSubmissions.tsx
 create mode 100644 src/bundled/review-configuration/submissions.test.ts
 create mode 100644 src/bundled/review-configuration/submissions.ts

diff --git a/docs/buzz-help.md b/docs/buzz-help.md
index 0ae02dbafc..a26d300450 100644
--- a/docs/buzz-help.md
+++ b/docs/buzz-help.md
@@ -1161,8 +1161,15 @@ confirmation. **Delete team** asks first; it doesn't delete the team's agents.
   reads the latest saved versions. Settings live on the community relay and are
   visible to channel readers; members who can post can edit them. A conflicting
   edit preserves your draft: copy your changes before cancelling and reloading.
-  This first version saves configuration and reviewer selections only. It does not
-  dispatch reviews, submit PRs, or send the planned 15-minute reminders.
+  **Submit PR** accepts a PR number or URL for a saved repository and one reviewer
+  per lane. **Start review threads** saves the instructions and creates an overview
+  plus a thread for each lane, mentioning its reviewer. The list retains delivery
+  status and **Open thread** actions. Repeating a PR reuses its saved submission;
+  **Resume submission** retries interrupted delivery from the original browser
+  profile. Reviewers must be owned by the signed-in identity and already belong
+  to the channel. A connected desktop agent runtime is needed for replies; delivery
+  alone does not mean a review started. GitHub metadata, pinned commits, review
+  verdicts, resubmission rounds, and the planned 15-minute reminders are not implemented.
 - A plugin's details in Manage plugins link to the Settings sections that hold
   its settings: sections it adds, such as GitHub comment authors, and Decisions
   API for a decision provider, such as TypeSafe. Only sections the Settings
diff --git a/src/bundled/review-configuration/README.md b/src/bundled/review-configuration/README.md
index 5ff546e41c..20e987d7a6 100644
--- a/src/bundled/review-configuration/README.md
+++ b/src/bundled/review-configuration/README.md
@@ -5,8 +5,12 @@ settings. Enable **Review Configuration** in Settings → Plugins → Manage plu
 Choose a channel, register a GitHub repository, add named lanes, reviewer agents, and instructions,
 and save. The repository table supports editing and an explicit reload.
 
-This is configuration only. It does not submit PRs, dispatch reviewers, create
-review threads, or send reminders. No agent or timer runs in the background.
+Use **Submit PR** to select a saved repository, enter a PR number or URL, and
+choose one configured reviewer per lane. **Start review threads** saves the
+instruction snapshot, creates an overview and one thread per lane, and mentions
+each selected reviewer with the complete lane instructions. The list retains
+thread links and delivery status. Sending does not prove that an agent is running
+or reviewing. No model process or reminder timer is started by this plugin.
 
 ## Getting started
 
@@ -73,5 +77,43 @@ Use a test channel. Saving does not activate any review automation.
 
 Reviewer choices come from the session’s shared agent inventory. Saved public keys
 remain visible and removable if an agent disappears or is archived. Unassigned
-lanes may be saved as drafts. Dispatch must check agent ownership and channel
-access when execution is implemented.
+lanes may be saved as drafts. Submission requires one available reviewer per lane,
+verified ownership by the signed-in user, and existing channel membership. The
+outbox rechecks membership before publishing mentions. Agent ownership is checked
+from fresh signed profiles; archive evidence and shared agent choices must be
+available. Run a connected agent in the desktop app to receive replies. A browser
+lab with registered identities alone cannot execute a review.
+
+## Submissions and recovery
+
+One `buzz.review.submission` artifact per channel/repository/PR stores the selected
+reviewers, instructions, configuration revision, and message IDs. Repeating a PR
+returns that record; resubmission rounds are not implemented. The PR URL is
+validated against the repository, but GitHub existence, permissions, title and
+commit are not fetched. Reviewers are asked to verify the PR and report the exact
+commit they reviewed. This does not post a GitHub review or claim an approval.
+
+Artifact create/CAS prevents competing submissions. A local profile identifier
+and Web Lock serialize delivery in the submitting profile; outbox recovery keeps
+the exact messages through lost receipts or interrupted artifact saves.
+**Resume submission** explicitly retries saved messages. A duplicate submission
+first returns the saved preview; it never silently dispatches an older selection. Other profiles can read
+the links but cannot take over incomplete delivery. If the original profile's
+recovery storage is lost, delivery stops instead of risking duplicate threads.
+Dispatch intent is saved before enqueueing. If that intent survives but both the
+message ID and recovery journal are missing, the row shows unconfirmed delivery
+and stops. A proven rejection before enqueue clears that intent for a later retry.
+A missing outbox message with a known ID is checked against the relay before
+recording delivery.
+No background retries, polling, or model runtime are added.
+
+Opening a channel adds one bounded submissions read (latest 100, with truncation
+notice). Submission explicitly reads the current record and reviewer profiles,
+refreshes agent choices, and uses the outbox's per-message membership preflight.
+Reconnect introduces no new plugin reads.
+
+Try Submit PR → Start review threads → reload → Open a lane thread. Check that
+the PR, reviewer mention and complete instructions are present. Submit the same
+PR again: it must reuse the saved threads. Test interrupted delivery with Resume
+from the same browser profile. Reminders, review verdict tracking, GitHub status
+synchronization, and new review rounds remain future work.
diff --git a/src/bundled/review-configuration/ReviewConfigurationPage.test.tsx b/src/bundled/review-configuration/ReviewConfigurationPage.test.tsx
index 0a1c86dabb..496cf55ad1 100644
--- a/src/bundled/review-configuration/ReviewConfigurationPage.test.tsx
+++ b/src/bundled/review-configuration/ReviewConfigurationPage.test.tsx
@@ -136,7 +136,7 @@ it("registers, reloads and edits a repository through the real form and artifact
   const user = await openDraft();
   await user.click(screen.getByRole("button", { name: "Save settings" }));
   await screen.findByText(
-    "Saved example-org/project. Reviews are not enabled yet.",
+    "Saved example-org/project. Use Submit PR to start review threads.",
   );
   await user.click(screen.getByRole("button", { name: "Reload" }));
   await screen.findByRole("button", { name: "Edit example-org/project" });
@@ -159,7 +159,7 @@ it("registers, reloads and edits a repository through the real form and artifact
   );
   await user.click(screen.getByRole("button", { name: "Save settings" }));
   await screen.findByText(
-    "Saved example-org/project. Reviews are not enabled yet.",
+    "Saved example-org/project. Use Submit PR to start review threads.",
   );
   expect(test.publish).toHaveBeenCalledTimes(2);
   expect(test.publish.mock.calls[1]?.[0].tags).toContainEqual([
@@ -198,7 +198,7 @@ it("keeps the draft on rejection, prevents duplicate submissions, and recovers",
   ).toContain("keyboard navigation");
   await user.click(screen.getByRole("button", { name: "Save settings" }));
   await screen.findByText(
-    "Saved example-org/project. Reviews are not enabled yet.",
+    "Saved example-org/project. Use Submit PR to start review threads.",
   );
 });
 
@@ -255,7 +255,7 @@ it("aborts an unfinished write when the page leaves its session", async () => {
 
 it("counts unreadable records toward the limit when a new repository is saved", async () => {
   const test = fixture();
-  test.snapshotRead.mockResolvedValueOnce(
+  test.snapshotRead.mockResolvedValue(
     Array.from({ length: 99 }, () => ({
       kind: 45010,
       id: "a".repeat(64),
@@ -285,7 +285,7 @@ it("counts unreadable records toward the limit when a new repository is saved",
   );
   await user.click(screen.getByRole("button", { name: "Save settings" }));
   await screen.findByText(
-    "Saved example-org/project. Reviews are not enabled yet.",
+    "Saved example-org/project. Use Submit PR to start review threads.",
   );
   expect(
     (
@@ -310,7 +310,7 @@ it("saves multiple lane reviewers, reloads their identities, and preserves unava
   );
   await user.click(screen.getByRole("button", { name: "Save settings" }));
   await screen.findByText(
-    "Saved example-org/project. Reviews are not enabled yet.",
+    "Saved example-org/project. Use Submit PR to start review threads.",
   );
   const content = test.publish.mock.calls[0]?.[0].content;
   expect(JSON.parse(content ?? "{}").lanes[0].reviewers).toEqual([
@@ -331,7 +331,7 @@ it("saves multiple lane reviewers, reloads their identities, and preserves unava
   );
   await user.click(screen.getByRole("button", { name: "Save settings" }));
   await screen.findByText(
-    "Saved example-org/project. Reviews are not enabled yet.",
+    "Saved example-org/project. Use Submit PR to start review threads.",
   );
   expect(
     JSON.parse(test.publish.mock.calls[1]?.[0].content ?? "{}").lanes[0]
@@ -354,7 +354,7 @@ it("refreshes failed agent and archive reads without discarding the draft", asyn
   );
   await user.click(screen.getByRole("button", { name: "Save settings" }));
   await screen.findByText(
-    "Saved example-org/project. Reviews are not enabled yet.",
+    "Saved example-org/project. Use Submit PR to start review threads.",
   );
   expect(
     JSON.parse(test.publish.mock.calls[0]?.[0].content ?? "null").lanes[0]
diff --git a/src/bundled/review-configuration/ReviewConfigurationPage.tsx b/src/bundled/review-configuration/ReviewConfigurationPage.tsx
index 97352cc2c8..82c3eef7cb 100644
--- a/src/bundled/review-configuration/ReviewConfigurationPage.tsx
+++ b/src/bundled/review-configuration/ReviewConfigurationPage.tsx
@@ -1,5 +1,8 @@
 import { useEffect, useRef, useState, type ReactNode } from "react";
 import { useAgentChoices } from "../../features/agents/use-choices";
+import { ReviewSubmissions } from "./ReviewSubmissions";
+import type { Navigation } from "../../features/navigation/controller";
+import { splitPartition } from "../../features/relay/partition";
 import { LaneReviewers } from "./LaneReviewers";
 import { useChannelList, useRelayConnection } from "../../features/relay/react";
 import type { RelayData } from "../../features/relay/service";
@@ -46,13 +49,34 @@ function Frame({ children }: { children: ReactNode }) {
   );
 }
 
-export function ReviewConfigurationPage({ relay }: { relay: RelayData }) {
+export function ReviewConfigurationPage({
+  relay,
+  navigator,
+}: {
+  relay: RelayData;
+  navigator?: Navigation;
+}) {
   const connection = useRelayConnection(relay);
   if (connection.status === "ready")
     return (
       <ReviewConfigurationCommunity
         key={`${connection.scope}:${connection.generation}`}
         session={connection.session}
+        onOpenThread={async (channelId, id) => {
+          const scope = splitPartition(connection.scope ?? "");
+          if (!navigator || !scope)
+            throw new Error("Thread navigation is unavailable.");
+          const result = await navigator.open({
+            version: 1,
+            kind: "conversation",
+            scope,
+            channelId,
+            messageId: id,
+            threadRootId: id,
+          });
+          if (result.status === "failed")
+            throw new Error("Could not open the review thread.");
+        }}
       />
     );
   return (
@@ -74,8 +98,10 @@ export function ReviewConfigurationPage({ relay }: { relay: RelayData }) {
 
 export function ReviewConfigurationCommunity({
   session,
+  onOpenThread,
 }: {
   session: RelaySession;
+  onOpenThread?: ((channel: string, id: string) => Promise<void>) | undefined;
 }) {
   const list = useChannelList(session.channels);
   const [channel, setChannel] = useState("");
@@ -99,7 +125,8 @@ export function ReviewConfigurationCommunity({
     <Frame>
       <p>
         Register repositories and save their review lane instructions. These are
-        draft settings; saving does not start reviews or send reminders.
+        saved settings; use Submit PR below to start reviewer threads. Saving
+        settings does not send messages.
       </p>
       <Select
         label="Review channel"
@@ -136,6 +163,7 @@ export function ReviewConfigurationCommunity({
           channel={channel}
           writable={writable}
           onEditingChange={setEditing}
+          onOpenThread={onOpenThread}
         />
       )}
     </Frame>
@@ -147,12 +175,15 @@ function ChannelConfiguration({
   channel,
   writable,
   onEditingChange,
+  onOpenThread,
 }: {
   session: RelaySession;
   channel: string;
   writable: boolean;
   onEditingChange: (editing: boolean) => void;
+  onOpenThread?: ((channel: string, id: string) => Promise<void>) | undefined;
 }) {
+  const [submitting, setSubmitting] = useState(false);
   const [rows, setRows] = useState<SavedReviewConfig[]>([]);
   const [loading, setLoading] = useState(true);
   const [error, setError] = useState("");
@@ -163,10 +194,10 @@ function ChannelConfiguration({
   const [editor, setEditor] = useState<SavedReviewConfig | "new">();
   const editorTrigger = useRef<HTMLButtonElement | null>(null);
   useEffect(() => {
-    onEditingChange(editor !== undefined);
+    onEditingChange(editor !== undefined || submitting);
     if (editor === undefined) editorTrigger.current?.focus();
     return () => onEditingChange(false);
-  }, [editor, onEditingChange]);
+  }, [editor, submitting, onEditingChange]);
   // biome-ignore lint/correctness/useExhaustiveDependencies: Reload explicitly requests a fresh snapshot.
   useEffect(() => {
     const controller = new AbortController();
@@ -215,7 +246,7 @@ function ChannelConfiguration({
       <InlineHeader title="Repositories" />
       <div className="review-config-actions">
         <Button
-          disabled={loading || !!editor}
+          disabled={loading || !!editor || submitting}
           onClick={() => {
             setNotice("");
             setReload((value) => value + 1);
@@ -226,7 +257,12 @@ function ChannelConfiguration({
         <Button
           variant="prominent"
           disabled={
-            loading || !!error || !!editor || !writable || remaining <= 0
+            loading ||
+            !!error ||
+            !!editor ||
+            submitting ||
+            !writable ||
+            remaining <= 0
           }
           onClick={(event) => {
             editorTrigger.current = event.currentTarget;
@@ -273,7 +309,7 @@ function ChannelConfiguration({
                 <td>
                   <Button
                     aria-label={`Edit ${row.config.repository}`}
-                    disabled={!!editor || !writable}
+                    disabled={!!editor || submitting || !writable}
                     onClick={(event) => {
                       editorTrigger.current = event.currentTarget;
                       setNotice("");
@@ -316,11 +352,20 @@ function ChannelConfiguration({
             );
             setEditor(undefined);
             setNotice(
-              `Saved ${saved.config.repository}. Reviews are not enabled yet.`,
+              `Saved ${saved.config.repository}. Use Submit PR to start review threads.`,
             );
           }}
         />
       )}
+      <ReviewSubmissions
+        session={session}
+        channel={channel}
+        configurations={rows}
+        disabled={!!editor || loading || !!error}
+        writable={writable}
+        onEditingChange={setSubmitting}
+        onOpenThread={onOpenThread}
+      />
     </>
   );
 }
@@ -560,7 +605,7 @@ function ConfigurationEditor({
         </Button>
       </div>
       <p>
-        Reminder interval: 15 minutes. Routing and reminder delivery will be
+        Reminder interval: 15 minutes. Automatic reminder delivery will be
         available in a later version.
       </p>
       {error && <p role="alert">{error}</p>}
diff --git a/src/bundled/review-configuration/ReviewSubmissions.test.tsx b/src/bundled/review-configuration/ReviewSubmissions.test.tsx
new file mode 100644
index 0000000000..e8e65af8ee
--- /dev/null
+++ b/src/bundled/review-configuration/ReviewSubmissions.test.tsx
@@ -0,0 +1,70 @@
+// @vitest-environment jsdom
+import { act, cleanup, render, screen } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { afterEach, expect, it } from "vitest";
+import type { RelaySession } from "../../features/relay/session";
+import { ReviewSubmissions } from "./ReviewSubmissions";
+import type { SavedReviewConfig } from "./configuration";
+
+afterEach(cleanup);
+
+it("waits for list reads before offering submission and restores trigger focus on cancel", async () => {
+  let finish: (events: []) => void = () => {};
+  const pending = new Promise<[]>((resolve) => {
+    finish = resolve;
+  });
+  const choices = {
+    pending: false,
+    selectable: [{ pubkey: "a".repeat(64), name: "Reviewer" }],
+    archives: { status: "ready" },
+  };
+  const session = {
+    snapshotRead: () => pending,
+    agentChoices: {
+      subscribe: () => () => {},
+      snapshot: () => choices,
+      retain: () => () => {},
+      ensure() {},
+    },
+  } as unknown as RelaySession;
+  const configuration: SavedReviewConfig = {
+    revision: "b".repeat(64),
+    artifactId: "config",
+    config: {
+      version: 1,
+      repository: "example-org/project",
+      reminderMinutes: 15,
+      lanes: [
+        {
+          id: "general",
+          name: "General",
+          instructions: "Check tests.",
+          reviewers: ["a".repeat(64)],
+        },
+      ],
+    },
+  };
+  render(
+    <ReviewSubmissions
+      session={session}
+      channel="channel"
+      configurations={[configuration]}
+      disabled={false}
+      writable
+      onEditingChange={() => {}}
+    />,
+  );
+  const submit = screen.getByRole("button", {
+    name: "Submit PR",
+  }) as HTMLButtonElement;
+  expect(submit.disabled).toBe(true);
+  await act(async () => finish([]));
+  expect(submit.disabled).toBe(false);
+  const user = userEvent.setup();
+  await user.click(submit);
+  expect(screen.getByRole("textbox", { name: "Pull request" })).toBe(
+    document.activeElement,
+  );
+  await user.click(screen.getByRole("button", { name: "Cancel" }));
+  expect(document.activeElement).toBe(submit);
+});
diff --git a/src/bundled/review-configuration/ReviewSubmissions.tsx b/src/bundled/review-configuration/ReviewSubmissions.tsx
new file mode 100644
index 0000000000..5fb289638c
--- /dev/null
+++ b/src/bundled/review-configuration/ReviewSubmissions.tsx
@@ -0,0 +1,406 @@
+import { useEffect, useRef, useState } from "react";
+import { useAgentChoices } from "../../features/agents/use-choices";
+import type { RelaySession } from "../../features/relay/session";
+import { Button } from "../../shared/design-system/ui/Button";
+import { Field } from "../../shared/design-system/ui/Field";
+import { InlineHeader } from "../../shared/design-system/ui/Header";
+import { Input } from "../../shared/design-system/ui/Input";
+import { Select } from "../../shared/design-system/ui/Select";
+import { SettingsGroup } from "../../shared/design-system/ui/SettingsGroup";
+import type { SavedReviewConfig } from "./configuration";
+import {
+  loadSubmissions,
+  prUrl,
+  submitReview,
+  type SavedSubmission,
+} from "./submissions";
+
+export function ReviewSubmissions({
+  session,
+  channel,
+  configurations,
+  disabled,
+  writable,
+  onEditingChange,
+  onOpenThread,
+}: {
+  session: RelaySession;
+  channel: string;
+  configurations: readonly SavedReviewConfig[];
+  disabled: boolean;
+  writable: boolean;
+  onEditingChange: (editing: boolean) => void;
+  onOpenThread?: ((channel: string, id: string) => Promise<void>) | undefined;
+}) {
+  const [rows, setRows] = useState<SavedSubmission[]>([]);
+  const [reload, setReload] = useState(0);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState("");
+  const [warning, setWarning] = useState("");
+  const [draft, setDraft] = useState<{
+    config: SavedReviewConfig;
+    existing?: SavedSubmission;
+  }>();
+  const trigger = useRef<HTMLButtonElement | null>(null);
+  useEffect(() => {
+    onEditingChange(!!draft);
+    if (!draft) trigger.current?.focus();
+    return () => onEditingChange(false);
+  }, [draft, onEditingChange]);
+  // biome-ignore lint/correctness/useExhaustiveDependencies: Reload is an explicit fresh read.
+  useEffect(() => {
+    const controller = new AbortController();
+    setLoading(true);
+    setError("");
+    loadSubmissions(
+      session,
+      channel,
+      AbortSignal.any([controller.signal, AbortSignal.timeout(20_000)]),
+    )
+      .then((result) => {
+        if (!controller.signal.aborted) {
+          setRows(result.rows);
+          setWarning(result.warning);
+        }
+      })
+      .catch((reason: unknown) => {
+        if (!controller.signal.aborted)
+          setError(
+            reason instanceof Error
+              ? reason.message
+              : "Could not load submissions.",
+          );
+      })
+      .finally(() => {
+        if (!controller.signal.aborted) setLoading(false);
+      });
+    return () => controller.abort();
+  }, [session, channel, reload]);
+  return (
+    <section className="review-config-form" aria-label="PR submissions">
+      <InlineHeader title="PR submissions" />
+      <p>
+        Submit a PR to start reviewer conversations using saved settings.
+        Delivery does not confirm that a reviewer is running. Automatic
+        reminders are off.
+      </p>
+      <div className="review-config-actions">
+        <Button
+          disabled={disabled || !!draft || loading}
+          onClick={() => setReload((value) => value + 1)}
+        >
+          Reload submissions
+        </Button>
+        <Button
+          variant="prominent"
+          disabled={
+            disabled ||
+            loading ||
+            !!draft ||
+            !writable ||
+            !configurations.length
+          }
+          onClick={(event) => {
+            trigger.current = event.currentTarget;
+            const first = configurations[0];
+            if (first) setDraft({ config: first });
+          }}
+        >
+          Submit PR
+        </Button>
+      </div>
+      {loading && <p role="status">Loading submissions…</p>}
+      {error && (
+        <p role="alert">{error} Use Reload submissions to try again.</p>
+      )}
+      {warning && <p role="alert">{warning}</p>}
+      {draft && (
+        <SubmissionForm
+          key={draft.existing?.artifactId ?? "new"}
+          session={session}
+          channel={channel}
+          configurations={configurations}
+          initial={draft.config}
+          existing={draft.existing}
+          writable={writable}
+          onClose={() => setDraft(undefined)}
+          onProgress={(record) =>
+            setRows((current) => [
+              record,
+              ...current.filter((row) => row.artifactId !== record.artifactId),
+            ])
+          }
+        />
+      )}
+      {!loading && !error && !rows.length && (
+        <p>No PRs submitted in this channel.</p>
+      )}
+      {rows.map((row) => (
+        <section
+          key={row.artifactId}
+          className="review-config-lane"
+          aria-label={`${row.value.config.repository}#${row.value.pr}`}
+        >
+          <InlineHeader
+            title={`${row.value.config.repository}#${row.value.pr}`}
+          />
+          <p>{prUrl(row.value)}</p>
+          {row.value.threads.map((thread, index) => (
+            <div
+              key={
+                index === 0
+                  ? "overview"
+                  : (row.value.config.lanes[index - 1]?.id ?? index)
+              }
+              className="review-config-actions"
+            >
+              <span>
+                {index === 0
+                  ? "Overview"
+                  : row.value.config.lanes[index - 1]?.name}
+                :{" "}
+                {thread.delivered
+                  ? "Request delivered"
+                  : thread.id || thread.started
+                    ? "Delivery unconfirmed"
+                    : "Not sent"}
+              </span>
+              {thread.id && (
+                <Button
+                  disabled={!onOpenThread || !!draft || disabled}
+                  onClick={async () => {
+                    try {
+                      if (thread.id) await onOpenThread?.(channel, thread.id);
+                    } catch (reason) {
+                      setError(
+                        reason instanceof Error
+                          ? reason.message
+                          : "Could not open thread.",
+                      );
+                    }
+                  }}
+                >
+                  Open{" "}
+                  {index === 0
+                    ? "overview"
+                    : row.value.config.lanes[index - 1]?.name}{" "}
+                  thread
+                </Button>
+              )}
+            </div>
+          ))}
+          {!row.value.threads.every((thread) => thread.delivered) && (
+            <div>
+              <Button
+                disabled={disabled || loading || !!draft || !writable}
+                onClick={(event) => {
+                  trigger.current = event.currentTarget;
+                  setDraft({
+                    config: {
+                      config: row.value.config,
+                      revision: row.value.configRevision,
+                      artifactId: "",
+                    },
+                    existing: row,
+                  });
+                }}
+              >
+                Resume submission
+              </Button>
+            </div>
+          )}
+        </section>
+      ))}
+    </section>
+  );
+}
+
+function SubmissionForm({
+  session,
+  channel,
+  configurations,
+  initial,
+  existing,
+  writable,
+  onClose,
+  onProgress,
+}: {
+  session: RelaySession;
+  channel: string;
+  configurations: readonly SavedReviewConfig[];
+  initial: SavedReviewConfig;
+  existing: SavedSubmission | undefined;
+  writable: boolean;
+  onClose: () => void;
+  onProgress: (record: SavedSubmission) => void;
+}) {
+  const choices = useAgentChoices(session, true, true);
+  const [config, setConfig] = useState(initial);
+  const [pr, setPr] = useState(existing ? String(existing.value.pr) : "");
+  const [reviewers, setReviewers] = useState(
+    initial.config.lanes.map((lane) => lane.reviewers[0] ?? ""),
+  );
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState("");
+  const [started, setStarted] = useState(!!existing);
+  const operation = useRef<AbortController | undefined>(undefined);
+  useEffect(() => () => operation.current?.abort(), []);
+  async function submit() {
+    if (operation.current || !writable) return;
+    const controller = new AbortController();
+    operation.current = controller;
+    setBusy(true);
+    setError("");
+    let recorded = started;
+    try {
+      await submitReview(
+        session,
+        channel,
+        config,
+        pr,
+        reviewers,
+        AbortSignal.any([controller.signal, AbortSignal.timeout(120_000)]),
+        (record) => {
+          if (!controller.signal.aborted) {
+            recorded = true;
+            setStarted(true);
+            setConfig({
+              config: record.value.config,
+              revision: record.value.configRevision,
+              artifactId: config.artifactId,
+            });
+            setPr(String(record.value.pr));
+            setReviewers(
+              record.value.config.lanes.map((lane) => lane.reviewers[0] ?? ""),
+            );
+            onProgress(record);
+          }
+        },
+        started,
+      );
+      if (!controller.signal.aborted) onClose();
+    } catch (reason) {
+      if (!controller.signal.aborted)
+        setError(
+          `${reason instanceof Error ? reason.message : "Could not submit."} ${recorded ? "Saved messages are retained. Close and reload submissions to check progress; Resume retries the same messages." : "Your draft is still here."}`,
+        );
+    } finally {
+      operation.current = undefined;
+      if (!controller.signal.aborted) setBusy(false);
+    }
+  }
+  return (
+    <form
+      className="review-config-form"
+      onSubmit={(event) => {
+        event.preventDefault();
+        void submit();
+      }}
+    >
+      <InlineHeader
+        title={started ? "Resume saved submission" : "New PR submission"}
+      />
+      <SettingsGroup layout="form">
+        <Select
+          label="Repository to review"
+          variant="field"
+          value={config.config.repository}
+          disabled={busy || started}
+          groups={[
+            {
+              label: "Repositories",
+              options: (existing ? [config] : configurations).map((row) => ({
+                value: row.config.repository,
+                label: row.config.repository,
+              })),
+            },
+          ]}
+          onValueChange={(repository) => {
+            const row = configurations.find(
+              (item) => item.config.repository === repository,
+            );
+            if (row) {
+              setConfig(row);
+              setReviewers(
+                row.config.lanes.map((lane) => lane.reviewers[0] ?? ""),
+              );
+            }
+          }}
+        />
+        <Field
+          label="Pull request"
+          description="PR number or full GitHub PR URL. The reviewer verifies the PR and current commit; Buzz does not fetch GitHub metadata here."
+        >
+          <Input
+            autoFocus
+            required
+            maxLength={300}
+            placeholder="https://github.com/example-org/project/pull/123"
+            value={pr}
+            disabled={busy || started}
+            onValueChange={setPr}
+          />
+        </Field>
+      </SettingsGroup>
+      {config.config.lanes.map((lane, index) => (
+        <section key={lane.id} className="review-config-lane">
+          <Select
+            variant="field"
+            label={`${lane.name} reviewer`}
+            value={reviewers[index] ?? ""}
+            required
+            disabled={busy || started}
+            placeholder="Choose a reviewer"
+            groups={[
+              {
+                label: "Configured reviewers",
+                options: lane.reviewers.map((key) => {
+                  const choice = choices.selectable.find(
+                    (item) => item.pubkey === key,
+                  );
+                  return {
+                    value: key,
+                    label:
+                      choice?.managedName ??
+                      choice?.name ??
+                      `Unavailable (${key.slice(0, 10)})`,
+                    disabled: !choice,
+                  };
+                }),
+              },
+            ]}
+            onValueChange={(value) =>
+              setReviewers((current) =>
+                current.map((item, i) => (i === index ? value : item)),
+              )
+            }
+          />
+          <details>
+            <summary>Instructions for {lane.name}</summary>
+            <p className="review-config-instructions">{lane.instructions}</p>
+          </details>
+        </section>
+      ))}
+      <p>
+        This sends a request to one reviewer per lane in this channel. Reviewers
+        must belong to your signed-in identity and already have channel access.
+        Their model runner must be connected to reply.
+      </p>
+      {error && <p role="alert">{error}</p>}
+      {busy && <p role="status">Saving submission and delivering threads…</p>}
+      <div className="review-config-actions">
+        <Button disabled={busy} onClick={onClose}>
+          {started ? "Close" : "Cancel"}
+        </Button>
+        <Button
+          type="submit"
+          variant="prominent"
+          loading={busy}
+          disabled={!writable || choices.pending}
+        >
+          {started ? "Resume delivery" : "Start review threads"}
+        </Button>
+      </div>
+    </form>
+  );
+}
diff --git a/src/bundled/review-configuration/index.tsx b/src/bundled/review-configuration/index.tsx
index e557e443d2..5e8312d6aa 100644
--- a/src/bundled/review-configuration/index.tsx
+++ b/src/bundled/review-configuration/index.tsx
@@ -1,15 +1,17 @@
 import type { PluginModule } from "../../plugins/api";
 import { ReviewConfigurationPage } from "./ReviewConfigurationPage";
 
-export const inject = ["pages", "relay"];
+export const inject = ["pages", "relay", "navigation"];
 export const apply: PluginModule["apply"] = (ctx) => {
-  const relay = ctx.relay;
+  const { relay, navigation: navigator } = ctx;
   ctx.pages.register({
     id: "configuration",
     title: "Review Configuration",
     layout: "workspace",
     primary: true,
     placement: "sidebar",
-    component: () => <ReviewConfigurationPage relay={relay} />,
+    component: () => (
+      <ReviewConfigurationPage relay={relay} navigator={navigator} />
+    ),
   });
 };
diff --git a/src/bundled/review-configuration/review-configuration.css b/src/bundled/review-configuration/review-configuration.css
index b12b427ebe..1bc0f186e6 100644
--- a/src/bundled/review-configuration/review-configuration.css
+++ b/src/bundled/review-configuration/review-configuration.css
@@ -47,3 +47,8 @@
   padding: var(--space-2);
   border-bottom: 1px solid var(--border-standard);
 }
+
+.review-config-instructions {
+  white-space: pre-wrap;
+  overflow-wrap: anywhere;
+}
diff --git a/src/bundled/review-configuration/submissions.test.ts b/src/bundled/review-configuration/submissions.test.ts
new file mode 100644
index 0000000000..5813ec798a
--- /dev/null
+++ b/src/bundled/review-configuration/submissions.test.ts
@@ -0,0 +1,363 @@
+import { afterEach, beforeEach, expect, it, vi } from "vitest";
+import { schnorr } from "@noble/curves/secp256k1.js";
+import { bytesToHex } from "nostr-tools/utils";
+import { createOutbox, type OutgoingEvent } from "../../features/relay/outbox";
+import type { EventData, ReadFilter } from "../../features/relay/events";
+import type { RelaySession } from "../../features/relay/session";
+import { keypair, signed } from "../../features/relay/testing";
+import { loadSubmissions, pullRequest, submitReview } from "./submissions";
+import type { SavedReviewConfig } from "./configuration";
+
+const channel = "11111111-1111-4111-8111-111111111111";
+const cleanups: (() => void)[] = [];
+beforeEach(() => {
+  const storage = new Map<string, string>();
+  vi.stubGlobal("localStorage", {
+    getItem: (key: string) => storage.get(key) ?? null,
+    setItem: (key: string, value: string) => storage.set(key, value),
+  });
+  let queue = Promise.resolve();
+  vi.stubGlobal("navigator", {
+    locks: {
+      request: (
+        _key: string,
+        _options: unknown,
+        run: () => Promise<unknown>,
+      ) => {
+        const task = queue.then(run);
+        queue = task.then(
+          () => {},
+          () => {},
+        );
+        return task;
+      },
+    },
+  });
+});
+afterEach(() => {
+  for (const cleanup of cleanups.splice(0)) cleanup();
+  vi.unstubAllGlobals();
+});
+
+async function fixture() {
+  const owner = keypair(),
+    agent = keypair();
+  const proof = bytesToHex(
+    schnorr.sign(
+      new Uint8Array(
+        await crypto.subtle.digest(
+          "SHA-256",
+          new TextEncoder().encode(`nostr:agent-auth:${agent.pubkey}:`),
+        ),
+      ),
+      owner.secret,
+    ),
+  );
+  let profile = signed(agent, {
+    kind: 0,
+    content: "{}",
+    tags: [["auth", owner.pubkey, "", proof]],
+  });
+  const heads = new Map<string, EventData>();
+  const messages = new Map<string, EventData>();
+  let journal: readonly OutgoingEvent[] = [];
+  const publish = vi.fn(async (event: EventData) => {
+    messages.set(event.id, event);
+  });
+  const box = createOutbox(
+    owner.pubkey,
+    { sign: async (template) => signed(owner, template), publish },
+    {
+      load: () => structuredClone(journal),
+      save: (next) => {
+        journal = structuredClone(next);
+      },
+    },
+  );
+  cleanups.push(box.dispose);
+  const artifactPublish = vi.fn(async (event: EventData) => {
+    const id = event.tags.find((tag) => tag[0] === "d")?.[1] ?? "";
+    const previous = heads.get(id);
+    if (event.tags.find((tag) => tag[0] === "prev")?.[1] !== previous?.id)
+      throw new Error("stale revision");
+    heads.set(id, event);
+    return event.id;
+  });
+  const session = {
+    viewer: owner.pubkey,
+    scope: `https://example.org:${owner.pubkey}`,
+    outbox: box.outbox,
+    agentChoices: {
+      refresh: async () => {},
+      snapshot: () => ({
+        archives: { status: "ready" },
+        selectable: [{ pubkey: agent.pubkey }],
+      }),
+    },
+    snapshotRead: vi.fn(async (filters: ReadFilter[]) => {
+      const filter = filters[0];
+      if (!filter) throw new Error("Missing filter");
+      if (filter.artifact && filter.consistency)
+        throw new Error("unsupported artifact predicate");
+      if (filter.kinds?.includes(0)) return [profile];
+      if (filter.kinds?.includes(9))
+        return [...messages.values()].filter((event) =>
+          filter.ids?.includes(event.id),
+        );
+      return [...heads.values()].filter(
+        (event) =>
+          !filter["#d"] ||
+          filter["#d"].includes(
+            event.tags.find((tag) => tag[0] === "d")?.[1] ?? "",
+          ),
+      );
+    }),
+    configArtifactWriter: {
+      sign: async (template: Parameters<typeof signed>[1]) =>
+        signed(owner, template),
+      publish: artifactPublish,
+    },
+  } as unknown as RelaySession;
+  const config: SavedReviewConfig = {
+    revision: "c".repeat(64),
+    artifactId: "config",
+    config: {
+      version: 1,
+      repository: "example-org/project",
+      reminderMinutes: 15,
+      lanes: [
+        {
+          id: "backend",
+          name: "Backend",
+          instructions: "Check authorization and tests.",
+          reviewers: [agent.pubkey],
+        },
+        {
+          id: "ui",
+          name: "UI",
+          instructions: "Check keyboard access.",
+          reviewers: [agent.pubkey],
+        },
+      ],
+    },
+  };
+  const run = (
+    input = "123",
+    signal = new AbortController().signal,
+    resume = false,
+  ) =>
+    submitReview(
+      session,
+      channel,
+      config,
+      input,
+      [agent.pubkey, agent.pubkey],
+      signal,
+      () => {},
+      resume,
+    );
+  return {
+    owner,
+    agent,
+    heads,
+    messages,
+    session,
+    config,
+    run,
+    publish,
+    artifactPublish,
+    box,
+    loseJournal() {
+      box.dispose();
+      journal = [];
+      const replacement = createOutbox(
+        owner.pubkey,
+        { sign: async (template) => signed(owner, template), publish },
+        { load: () => [], save: () => {} },
+      );
+      cleanups.push(replacement.dispose);
+      (session as { outbox: typeof replacement.outbox }).outbox =
+        replacement.outbox;
+    },
+    changeOwner() {
+      profile = signed(agent, { kind: 0, content: "{}", tags: [] });
+    },
+  };
+}
+
+it("validates canonical PR input and refuses other repositories or non-PR URLs", () => {
+  expect(pullRequest("#42", "example-org/project")).toBe(42);
+  expect(
+    pullRequest(
+      "https://github.com/Example-Org/Project/pull/42/",
+      "example-org/project",
+    ),
+  ).toBe(42);
+  for (const input of [
+    "0",
+    "1.5",
+    "9007199254740992",
+    "https://github.com/other/project/pull/1",
+    "https://github.com/example-org/project/issues/1",
+    "https://user@github.com/example-org/project/pull/1",
+    "https://github.com/example-org/project/pull/1?x=2",
+  ])
+    expect(() => pullRequest(input, "example-org/project")).toThrow();
+});
+
+it("saves the instruction snapshot and creates one overview plus distinct lane threads", async () => {
+  const f = await fixture();
+  const record = await f.run();
+  expect(record.value.threads.every((thread) => thread.delivered)).toBe(true);
+  expect(f.messages.size).toBe(3);
+  const messages = [...f.messages.values()];
+  expect(messages[0]?.tags.some((tag) => tag[0] === "p")).toBe(false);
+  for (const [index, message] of messages.slice(1).entries()) {
+    expect(message.tags).toContainEqual(["p", f.agent.pubkey]);
+    expect(message.tags.some((tag) => tag[0] === "e")).toBe(false);
+    expect(message.content).toContain(
+      f.config.config.lanes[index]?.instructions,
+    );
+    expect(message.content).toContain(record.value.threads[0]?.id);
+  }
+  expect(
+    (await loadSubmissions(f.session, channel, new AbortController().signal))
+      .rows[0],
+  ).toEqual(record);
+  await f.run();
+  expect(f.publish).toHaveBeenCalledTimes(3);
+});
+
+it("serializes simultaneous submissions of the same PR", async () => {
+  const f = await fixture();
+  const [first, second] = await Promise.all([f.run(), f.run()]);
+  expect(first.value.threads).toEqual(second.value.threads);
+  expect(f.messages.size).toBe(3);
+});
+
+it("retries the same signed event after ambiguous publication without duplicating threads", async () => {
+  const f = await fixture();
+  f.publish.mockImplementationOnce(async (event) => {
+    f.messages.set(event.id, event);
+    throw new Error("Receipt lost");
+  });
+  await expect(f.run()).rejects.toThrow();
+  const firstId = f.publish.mock.calls[0]?.[0].id;
+  await f.run("123", undefined, true);
+  expect(f.publish.mock.calls[1]?.[0].id).toBe(firstId);
+  expect(f.messages.size).toBe(3);
+});
+
+it("recovers a send whose artifact update failed before its ID was saved", async () => {
+  const f = await fixture();
+  const original = f.artifactPublish.getMockImplementation();
+  if (!original) throw new Error("Missing fixture publisher");
+  f.artifactPublish
+    .mockImplementationOnce(original)
+    .mockImplementationOnce(original)
+    .mockRejectedValueOnce(new Error("save interrupted"));
+  await expect(f.run()).rejects.toThrow("save interrupted");
+  await f.run("123", undefined, true);
+  expect(f.messages.size).toBe(3);
+  expect(f.publish).toHaveBeenCalledTimes(3);
+});
+
+it("does not take over incomplete delivery after browser recovery storage is lost", async () => {
+  const f = await fixture();
+  f.publish.mockRejectedValueOnce(new Error("offline"));
+  await expect(f.run()).rejects.toThrow();
+  localStorage.setItem(
+    `buzz.review.device:${f.session.scope}`,
+    crypto.randomUUID(),
+  );
+  await expect(f.run("123", undefined, true)).rejects.toThrow(
+    "original browser profile",
+  );
+  expect(f.publish).toHaveBeenCalledTimes(1);
+});
+
+it("refuses unattested reviewers before saving or sending", async () => {
+  const f = await fixture();
+  f.changeOwner();
+  await expect(f.run()).rejects.toThrow("verified ownership");
+  expect(f.heads.size).toBe(0);
+  expect(f.publish).not.toHaveBeenCalled();
+});
+
+it("stops on cancellation and resumes only the saved message IDs", async () => {
+  const f = await fixture();
+  const controller = new AbortController();
+  f.publish.mockImplementationOnce(async (event) => {
+    f.messages.set(event.id, event);
+    controller.abort();
+  });
+  await expect(f.run("123", controller.signal)).rejects.toThrow();
+  const firstId = f.publish.mock.calls[0]?.[0].id;
+  await f.run("123", undefined, true);
+  expect(f.messages.has(firstId ?? "")).toBe(true);
+  expect(f.messages.size).toBe(3);
+});
+
+it("opens an existing incomplete record without sending a changed preview", async () => {
+  const f = await fixture();
+  f.publish.mockRejectedValueOnce(new Error("offline"));
+  await expect(f.run()).rejects.toThrow();
+  const changed = {
+    ...f.config,
+    config: {
+      ...f.config.config,
+      lanes: f.config.config.lanes.map((lane) => ({
+        ...lane,
+        instructions: "New instructions",
+      })),
+    },
+  };
+  const record = await submitReview(
+    f.session,
+    channel,
+    changed,
+    "123",
+    [f.agent.pubkey, f.agent.pubkey],
+    new AbortController().signal,
+    () => {},
+  );
+  expect(record.value.config.lanes[0]?.instructions).toBe(
+    "Check authorization and tests.",
+  );
+  expect(f.publish).toHaveBeenCalledTimes(1);
+});
+
+it("fails closed when a sent message loses its journal before its ID was saved", async () => {
+  const f = await fixture();
+  const original = f.artifactPublish.getMockImplementation();
+  if (!original) throw new Error("Missing fixture publisher");
+  f.artifactPublish
+    .mockImplementationOnce(original)
+    .mockImplementationOnce(original)
+    .mockRejectedValueOnce(new Error("save interrupted"));
+  await expect(f.run()).rejects.toThrow("save interrupted");
+  await vi.waitFor(() => expect(f.publish).toHaveBeenCalledTimes(1));
+  f.loseJournal();
+  await expect(f.run("123", undefined, true)).rejects.toThrow(
+    "recovery journal is missing",
+  );
+  expect(f.publish).toHaveBeenCalledTimes(1);
+});
+
+it("can resume after a proven rejection before enqueue", async () => {
+  const f = await fixture();
+  const send = vi.fn(f.box.outbox.send).mockImplementationOnce(() => {
+    throw new Error("Outbox full");
+  });
+  (f.session as { outbox: typeof f.box.outbox }).outbox = {
+    ...f.box.outbox,
+    send,
+  };
+  await expect(f.run()).rejects.toThrow("Outbox full");
+  const saved = (
+    await loadSubmissions(f.session, channel, new AbortController().signal)
+  ).rows[0];
+  expect(saved?.value.threads[0]).toEqual({});
+  await f.run("123", undefined, true);
+  expect(f.messages.size).toBe(3);
+});
diff --git a/src/bundled/review-configuration/submissions.ts b/src/bundled/review-configuration/submissions.ts
new file mode 100644
index 0000000000..a6cb7d345a
--- /dev/null
+++ b/src/bundled/review-configuration/submissions.ts
@@ -0,0 +1,515 @@
+import { npubEncode } from "nostr-tools/nip19";
+import { profileMentionLink } from "../../features/messages/message-edit";
+import {
+  ARTIFACT_KIND,
+  uuidv5,
+} from "../../features/agents/agent-config-artifacts";
+import { attestedOwner } from "../../features/agents/owner-attestation";
+import type { EventData } from "../../features/relay/events";
+import type { Outbox } from "../../features/relay/outbox";
+import type { RelaySession } from "../../features/relay/session";
+import {
+  repositoryName,
+  validateConfig,
+  type ReviewConfig,
+  type SavedReviewConfig,
+} from "./configuration";
+
+const TYPE = "buzz.review.submission";
+const HEX = /^[0-9a-f]{64}$/;
+const UUID = /^[0-9a-f-]{36}$/;
+type Thread = { id?: string; started?: true; delivered?: true };
+export type Submission = {
+  version: 1;
+  pr: number;
+  config: ReviewConfig;
+  configRevision: string;
+  submitter: string;
+  device: string;
+  threads: Thread[];
+};
+export type SavedSubmission = {
+  value: Submission;
+  artifactId: string;
+  revision: string;
+};
+const tag = (event: EventData, name: string) =>
+  event.tags.find((t) => t[0] === name)?.[1];
+const identity = (channel: string, repository: string, pr: number) =>
+  uuidv5(channel, `${TYPE}:${repository}:${pr}`);
+export const prUrl = (value: Submission) =>
+  `https://github.com/${value.config.repository}/pull/${value.pr}`;
+export const threadUrl = (channel: string, id: string) =>
+  `buzz://message?channel=${channel}&id=${id}`;
+
+export function pullRequest(input: string, repository: string): number {
+  const text = input.trim();
+  const match =
+    /^https:\/\/github\.com\/([^/]+\/[^/]+)\/pull\/([1-9]\d*)\/?$/i.exec(text);
+  if (match && repositoryName(match[1] ?? "") !== repository)
+    throw new Error("This PR belongs to a different repository.");
+  const number = /^(?:#)?[1-9]\d*$/.test(text)
+    ? Number(text.replace(/^#/, ""))
+    : match
+      ? Number(match[2])
+      : NaN;
+  if (!Number.isSafeInteger(number) || number < 1)
+    throw new Error(
+      "Enter a PR number or its full https://github.com pull request URL.",
+    );
+  return number;
+}
+
+async function decode(
+  event: EventData,
+  channel: string,
+): Promise<SavedSubmission> {
+  if (
+    event.kind !== ARTIFACT_KIND ||
+    tag(event, "h") !== channel ||
+    tag(event, "type") !== TYPE
+  )
+    throw new Error("Unexpected review submission.");
+  const value = JSON.parse(event.content) as Submission;
+  const config = validateConfig(value.config);
+  if (
+    value.version !== 1 ||
+    !Number.isSafeInteger(value.pr) ||
+    value.pr < 1 ||
+    value.submitter !== event.pubkey ||
+    !HEX.test(value.configRevision) ||
+    !UUID.test(value.device) ||
+    config.lanes.some((lane) => lane.reviewers.length !== 1) ||
+    !Array.isArray(value.threads) ||
+    value.threads.length !== config.lanes.length + 1 ||
+    value.threads.some(
+      (thread) =>
+        !thread ||
+        (thread.started !== undefined && thread.started !== true) ||
+        (thread.id !== undefined && !HEX.test(thread.id)) ||
+        (thread.delivered !== undefined &&
+          (thread.delivered !== true || !thread.id)),
+    )
+  )
+    throw new Error("Invalid review submission.");
+  const artifactId = await identity(channel, config.repository, value.pr);
+  if (tag(event, "d") !== artifactId)
+    throw new Error("Invalid submission identity.");
+  return { value: { ...value, config }, artifactId, revision: event.id };
+}
+
+export async function loadSubmissions(
+  session: RelaySession,
+  channel: string,
+  signal: AbortSignal,
+) {
+  if (!session.snapshotRead)
+    throw new Error("This connection cannot read submissions.");
+  const events = await session.snapshotRead(
+    [
+      {
+        kinds: [ARTIFACT_KIND],
+        "#h": [channel],
+        "#type": [TYPE],
+        artifact: "current",
+        limit: 101,
+      },
+    ],
+    { signal },
+  );
+  const results = await Promise.allSettled(
+    events.slice(0, 100).map((event) => decode(event, channel)),
+  );
+  return {
+    rows: results.flatMap((result) =>
+      result.status === "fulfilled" ? [result.value] : [],
+    ),
+    warning: [
+      events.length > 100 ? "Showing the latest 100 submissions." : "",
+      results.some((result) => result.status === "rejected")
+        ? "Some saved submissions could not be read."
+        : "",
+    ]
+      .filter(Boolean)
+      .join(" "),
+  };
+}
+
+async function write(
+  session: RelaySession,
+  channel: string,
+  value: Submission,
+  previous: SavedSubmission | undefined,
+  signal: AbortSignal,
+): Promise<SavedSubmission> {
+  const writer = session.configArtifactWriter;
+  if (!writer) throw new Error("This connection cannot save submissions.");
+  signal.throwIfAborted();
+  const artifactId = await identity(channel, value.config.repository, value.pr);
+  const event = await writer.sign(
+    {
+      kind: ARTIFACT_KIND,
+      created_at: Math.floor(Date.now() / 1000),
+      content: JSON.stringify(value),
+      tags: [
+        ["ar", "1"],
+        ["d", artifactId],
+        ["h", channel],
+        ["type", TYPE],
+        ["title", `Review: ${value.config.repository}#${value.pr}`],
+        ["op", previous ? "update" : "create"],
+        ...(previous ? [["prev", previous.revision]] : []),
+      ],
+    },
+    signal,
+  );
+  await writer.publish(event, signal);
+  return { value, artifactId, revision: event.id };
+}
+
+/** Device ownership is recovery coordination, never permission. The relay still
+ * authorizes every write. Shared Web Locks serialize tabs; artifact create/CAS
+ * serializes devices. Losing this profile cannot authorize replacement sends. */
+function deviceId(scope: string) {
+  const key = `buzz.review.device:${scope}`;
+  let value = localStorage.getItem(key);
+  if (!value) {
+    value = crypto.randomUUID();
+    localStorage.setItem(key, value);
+  }
+  if (!UUID.test(value))
+    throw new Error("Submission recovery storage is unavailable.");
+  return value;
+}
+
+export function threadMessage(
+  value: Submission,
+  channel: string,
+  index: number,
+  reviewerName = "Reviewer",
+) {
+  const lane = value.config.lanes[index - 1];
+  const title = `${value.config.repository}#${value.pr}${lane ? ` · ${lane.name}` : " · Review"}`;
+  return {
+    kind: 9,
+    tags: [
+      ["h", channel],
+      ["subject", title],
+      ...(lane ? [["p", lane.reviewers[0] ?? ""]] : []),
+    ],
+    content: lane
+      ? `Review request: ${prUrl(value)}\n\nReviewer: ${profileMentionLink(`@${reviewerName}`, `nostr:${npubEncode(lane.reviewers[0] ?? "")}`)}\nLane: ${lane.name}\n\n${lane.instructions}\n\nReply in this thread with the commit you reviewed, findings, and any blockers. Verify the current PR and repository before reviewing. This submission does not pin a commit or post a GitHub review.\n\nOverview: ${threadUrl(channel, value.threads[0]?.id ?? "")}`
+      : `Review request: ${prUrl(value)}\n\nLanes: ${value.config.lanes.map((item) => item.name).join(", ")}\n\nLane threads and delivery status are listed in Review Configuration. A delivered request does not mean the reviewer has started. Automatic reminders are off.`,
+  };
+}
+
+async function eligible(
+  session: RelaySession,
+  value: Submission,
+  signal: AbortSignal,
+) {
+  await session.agentChoices.refresh(true, { fresh: true });
+  signal.throwIfAborted();
+  const choices = session.agentChoices.snapshot();
+  if (choices.archives.status !== "ready" || choices.archives.error)
+    throw new Error(
+      "Refresh agents after archive access is restored before submitting.",
+    );
+  const keys = [
+    ...new Set(value.config.lanes.map((lane) => lane.reviewers[0] ?? "")),
+  ];
+  if (
+    keys.some(
+      (key) => !choices.selectable.some((choice) => choice.pubkey === key),
+    )
+  )
+    throw new Error(
+      "A selected reviewer is unavailable. Update the saved reviewer assignments.",
+    );
+  if (!session.snapshotRead)
+    throw new Error("Submission reads are unavailable.");
+  const profiles = await session.snapshotRead(
+    [{ kinds: [0], authors: keys, limit: keys.length, consistency: "strong" }],
+    { signal },
+  );
+  for (const key of keys) {
+    const profile = profiles
+      .filter((event) => event.kind === 0 && event.pubkey === key)
+      .sort(
+        (a, b) => b.created_at - a.created_at || a.id.localeCompare(b.id),
+      )[0];
+    if (!profile || (await attestedOwner(profile)) !== session.viewer)
+      throw new Error(
+        "Submission currently requires reviewers with verified ownership by your signed-in identity.",
+      );
+  }
+}
+
+function delivered(
+  outbox: Outbox,
+  id: string,
+  signal: AbortSignal,
+): Promise<void> {
+  return new Promise((resolve, reject) => {
+    let stop = () => {};
+    const finish = (error?: Error) => {
+      stop();
+      signal.removeEventListener("abort", abort);
+      error ? reject(error) : resolve();
+    };
+    const abort = () =>
+      finish(
+        new Error(
+          "Delivery was interrupted. Resume this submission to check its saved messages.",
+        ),
+      );
+    const check = () => {
+      const item = outbox.snapshot().find((entry) => entry.event.id === id);
+      if (!item)
+        return finish(
+          new Error(
+            "Reload this page to recover delivery from the shared outbox.",
+          ),
+        );
+      if (item.delivery === "accepted" || item.delivery === "seen") finish();
+      else if (item.delivery === "failed" || item.delivery === "unknown")
+        finish(
+          new Error(
+            item.error ??
+              "Delivery is unconfirmed. Resume to retry the same message.",
+          ),
+        );
+    };
+    stop = outbox.subscribe(check);
+    signal.addEventListener("abort", abort, { once: true });
+    if (signal.aborted) abort();
+    else check();
+  });
+}
+
+/** Explicit user action only. There is no background dispatcher or polling. */
+export async function submitReview(
+  session: RelaySession,
+  channel: string,
+  saved: SavedReviewConfig,
+  input: string,
+  reviewers: readonly string[],
+  signal: AbortSignal,
+  onProgress: (value: SavedSubmission) => void,
+  resume = false,
+) {
+  const outbox = session.outbox;
+  const read = session.snapshotRead;
+  if (!outbox?.supports(9) || !read || !navigator.locks)
+    throw new Error(
+      "This client cannot submit reviews. Use a client with durable message delivery.",
+    );
+  if (!session.viewer) throw new Error("Sign in before submitting a review.");
+  const viewer = session.viewer;
+  const pr = pullRequest(input, saved.config.repository);
+  const artifactId = await identity(channel, saved.config.repository, pr);
+  return navigator.locks.request(
+    `buzz.review.submit:${session.scope}`,
+    { signal },
+    async () => {
+      const device = deviceId(session.scope);
+      await outbox.ready();
+      const events = await read(
+        [
+          {
+            kinds: [ARTIFACT_KIND],
+            "#h": [channel],
+            "#d": [artifactId],
+            artifact: "current",
+            limit: 1,
+          },
+        ],
+        { signal },
+      );
+      let record: SavedSubmission;
+      const head = events[0];
+      if (head) record = await decode(head, channel);
+      else {
+        const config = validateConfig({
+          ...saved.config,
+          lanes: saved.config.lanes.map((lane, i) => {
+            const reviewer = reviewers[i];
+            if (!reviewer || !lane.reviewers.includes(reviewer))
+              throw new Error(`Choose a configured reviewer for ${lane.name}.`);
+            return { ...lane, reviewers: [reviewer] };
+          }),
+        });
+        const value: Submission = {
+          version: 1,
+          pr,
+          config,
+          configRevision: saved.revision,
+          submitter: viewer,
+          device,
+          threads: Array.from({ length: config.lanes.length + 1 }, () => ({})),
+        };
+        await eligible(session, value, signal);
+        record = await write(session, channel, value, undefined, signal);
+      }
+      onProgress(record);
+      // A duplicate opens the saved preview; only explicit Resume can dispatch it.
+      if (head && !resume) return record;
+      if (record.value.threads.every((thread) => thread.delivered)) {
+        for (const thread of record.value.threads)
+          if (thread.id) await outbox.acknowledge(thread.id);
+        return record;
+      }
+      if (
+        record.value.submitter !== session.viewer ||
+        record.value.device !== device
+      )
+        throw new Error(
+          "This PR is already submitted. Resume incomplete delivery from the original browser profile; existing threads remain available here.",
+        );
+      if (head) await eligible(session, record.value, signal);
+      for (const [index, thread] of record.value.threads.entries()) {
+        signal.throwIfAborted();
+        const key = `${artifactId}:${index}`;
+        if (thread.delivered) {
+          if (thread.id) await outbox.acknowledge(thread.id);
+          continue;
+        }
+        const recovery = await outbox.recovery(key);
+        let id = thread.id ?? recovery?.event.id;
+        if (thread.id && recovery && thread.id !== recovery.event.id)
+          throw new Error(
+            "Submission recovery does not match the saved thread. Delivery stopped.",
+          );
+        if (id && !recovery) {
+          const messages = await read(
+            [
+              {
+                ids: [id],
+                kinds: [9],
+                "#h": [channel],
+                limit: 1,
+                consistency: "strong",
+              },
+            ],
+            { signal },
+          );
+          if (
+            !messages.some(
+              (event) => event.id === id && event.pubkey === session.viewer,
+            )
+          )
+            throw new Error(
+              "The saved message is unavailable and its local recovery is missing. Delivery stopped to avoid creating a duplicate thread.",
+            );
+        } else {
+          const active = () => !signal.aborted;
+          if (recovery) {
+            if (!outbox.snapshot().some((item) => item.event.id === id))
+              throw new Error(
+                "Reload this page to recover the saved message from another window.",
+              );
+            if (
+              recovery.delivery !== "accepted" &&
+              recovery.delivery !== "seen" &&
+              recovery.delivery !== "sending"
+            )
+              outbox.retry(recovery.event.id, active);
+          } else {
+            if (thread.started)
+              throw new Error(
+                "Delivery was started but its recovery journal is missing. Check the channel; no replacement thread was created.",
+              );
+            record = await write(
+              session,
+              channel,
+              {
+                ...record.value,
+                threads: record.value.threads.map((item, i) =>
+                  i === index ? { started: true } : item,
+                ),
+              },
+              record,
+              signal,
+            );
+            onProgress(record);
+            signal.throwIfAborted();
+            try {
+              id = outbox.send(
+                threadMessage(
+                  record.value,
+                  channel,
+                  index,
+                  session.agentChoices
+                    .snapshot()
+                    .selectable.find(
+                      (choice) =>
+                        choice.pubkey ===
+                        record.value.config.lanes[index - 1]?.reviewers[0],
+                    )?.name,
+                ),
+                { key, value: artifactId },
+                active,
+              );
+            } catch (reason) {
+              // Admission can fail before enqueue (for example a full outbox).
+              // Only this still-active invocation can prove nothing was queued.
+              if (!signal.aborted && !(await outbox.recovery(key))) {
+                record = await write(
+                  session,
+                  channel,
+                  {
+                    ...record.value,
+                    threads: record.value.threads.map((item, i) =>
+                      i === index ? {} : item,
+                    ),
+                  },
+                  record,
+                  signal,
+                );
+                onProgress(record);
+              }
+              throw reason;
+            }
+          }
+          const sentId = id;
+          if (!sentId)
+            throw new Error("Message delivery did not return an identity.");
+          if (!thread.id) {
+            record = await write(
+              session,
+              channel,
+              {
+                ...record.value,
+                threads: record.value.threads.map((item, i) =>
+                  i === index ? { id: sentId } : item,
+                ),
+              },
+              record,
+              signal,
+            );
+            onProgress(record);
+          }
+          await delivered(outbox, sentId, signal);
+        }
+        const deliveredId = id;
+        if (!deliveredId)
+          throw new Error("Missing delivered message identity.");
+        record = await write(
+          session,
+          channel,
+          {
+            ...record.value,
+            threads: record.value.threads.map((item, i) =>
+              i === index ? { id: deliveredId, delivered: true } : item,
+            ),
+          },
+          record,
+          signal,
+        );
+        onProgress(record);
+        await outbox.acknowledge(deliveredId);
+      }
+      return record;
+    },
+  );
+}

From b8531d8ef9b67e043c4702265986905898c8845c Mon Sep 17 00:00:00 2001
From: Ravneet Arora <rarora@squareup.com>
Date: Thu, 12 Nov 2026 12:16:18 -0500
Subject: [PATCH 04/17] Route PR reviews to matching lanes

Preview title, label, file-count, and path rules before sending. Keep new submissions to lane threads, retain legacy recovery, and collapse saved PR details.

Co-authored-by: maincourse <37ce551b493d4a998caf030929c47bce0b6a0e43f1178b3a63c4151d7c16b76e@buzz.block.builderlab.xyz>
Signed-off-by: Ravneet Arora <rarora@squareup.com>
---
 docs/buzz-help.md                             |  14 +-
 .../review-configuration/LaneRules.tsx        | 142 +++++++
 src/bundled/review-configuration/README.md    |  41 +-
 .../ReviewConfigurationPage.test.tsx          | 139 +++++-
 .../ReviewConfigurationPage.tsx               |  49 ++-
 .../ReviewSubmissions.test.tsx                |  96 +++++
 .../ReviewSubmissions.tsx                     | 397 ++++++++++++------
 .../review-configuration/configuration.ts     |   5 +
 src/bundled/review-configuration/index.tsx    |  11 +-
 .../review-configuration/manifest.json        |  14 +-
 .../review-configuration/pull-facts.test.ts   | 121 ++++++
 .../review-configuration/pull-facts.ts        | 183 ++++++++
 .../review-configuration.css                  |   8 +
 .../review-configuration/routing.test.ts      |  98 +++++
 src/bundled/review-configuration/routing.ts   | 176 ++++++++
 .../review-configuration/submissions.test.ts  | 136 +++++-
 .../review-configuration/submissions.ts       |  42 +-
 17 files changed, 1495 insertions(+), 177 deletions(-)
 create mode 100644 src/bundled/review-configuration/LaneRules.tsx
 create mode 100644 src/bundled/review-configuration/pull-facts.test.ts
 create mode 100644 src/bundled/review-configuration/pull-facts.ts
 create mode 100644 src/bundled/review-configuration/routing.test.ts
 create mode 100644 src/bundled/review-configuration/routing.ts

diff --git a/docs/buzz-help.md b/docs/buzz-help.md
index a26d300450..6fcb6b3a96 100644
--- a/docs/buzz-help.md
+++ b/docs/buzz-help.md
@@ -1162,14 +1162,20 @@ confirmation. **Delete team** asks first; it doesn't delete the team's agents.
   visible to channel readers; members who can post can edit them. A conflicting
   edit preserves your draft: copy your changes before cancelling and reloading.
   **Submit PR** accepts a PR number or URL for a saved repository and one reviewer
-  per lane. **Start review threads** saves the instructions and creates an overview
-  plus a thread for each lane, mentioning its reviewer. The list retains delivery
+  per matching lane. Optional all/any rules match title text, exact labels, changed-file
+  counts, and path patterns such as `src/**/*.tsx`. No rules matches every PR.
+  **Load PR details** previews matching lanes; zero matches sends nothing.
+  **Start review threads** rechecks the PR, saves the instructions, and creates
+  one thread per matching lane, mentioning its reviewer. Earlier submissions
+  retain their existing overview links. The page remembers your selected channel. The list retains delivery
   status and **Open thread** actions. Repeating a PR reuses its saved submission;
   **Resume submission** retries interrupted delivery from the original browser
   profile. Reviewers must be owned by the signed-in identity and already belong
   to the channel. A connected desktop agent runtime is needed for replies; delivery
-  alone does not mean a review started. GitHub metadata, pinned commits, review
-  verdicts, resubmission rounds, and the planned 15-minute reminders are not implemented.
+  alone does not mean a review started. Desktop uses signed-in GitHub access;
+  browser metadata reads support public PRs only and may hit GitHub rate limits.
+  PRs above 3,000 changed files or 100 labels are unsupported. Pinned reviewer
+  checkouts, review verdicts, resubmission rounds, and reminders are not implemented.
 - A plugin's details in Manage plugins link to the Settings sections that hold
   its settings: sections it adds, such as GitHub comment authors, and Decisions
   API for a decision provider, such as TypeSafe. Only sections the Settings
diff --git a/src/bundled/review-configuration/LaneRules.tsx b/src/bundled/review-configuration/LaneRules.tsx
new file mode 100644
index 0000000000..8a775696c5
--- /dev/null
+++ b/src/bundled/review-configuration/LaneRules.tsx
@@ -0,0 +1,142 @@
+import { Button } from "../../shared/design-system/ui/Button";
+import { Field } from "../../shared/design-system/ui/Field";
+import { Input } from "../../shared/design-system/ui/Input";
+import { Select } from "../../shared/design-system/ui/Select";
+import {
+  ruleFields,
+  ruleOperators,
+  type LaneRule,
+  type LaneRouting,
+} from "./routing";
+
+export function LaneRules({
+  lane,
+  value,
+  disabled,
+  onChange,
+}: {
+  lane: number;
+  value: LaneRouting | undefined;
+  disabled: boolean;
+  onChange: (value: LaneRouting) => void;
+}) {
+  const routing = value ?? { mode: "all", rules: [] };
+  const update = (index: number, rule: LaneRule) =>
+    onChange({
+      ...routing,
+      rules: routing.rules.map((item, i) => (i === index ? rule : item)),
+    });
+  return (
+    <>
+      <Select
+        label={`Lane ${lane} routing`}
+        variant="field"
+        disabled={disabled}
+        value={routing.mode}
+        description="No rules matches every PR. A PR can match several lanes."
+        groups={[
+          {
+            label: "Match",
+            options: [
+              { value: "all", label: "Match all rules" },
+              { value: "any", label: "Match any rule" },
+            ],
+          },
+        ]}
+        onValueChange={(mode) =>
+          onChange({ ...routing, mode: mode as LaneRouting["mode"] })
+        }
+      />
+      {routing.rules.map((rule, index) => (
+        <div className="review-config-form" key={rule.id}>
+          <Select
+            label={`Lane ${lane} rule ${index + 1} field`}
+            variant="field"
+            disabled={disabled}
+            value={rule.field}
+            groups={[{ label: "PR field", options: [...ruleFields] }]}
+            onValueChange={(raw) => {
+              const field = raw as LaneRule["field"];
+              update(index, {
+                id: rule.id,
+                field,
+                operator: ruleOperators[field][0].value,
+                value: "",
+              });
+            }}
+          />
+          <Select
+            label={`Lane ${lane} rule ${index + 1} comparison`}
+            variant="field"
+            disabled={disabled}
+            value={rule.operator}
+            groups={[
+              { label: "Comparison", options: [...ruleOperators[rule.field]] },
+            ]}
+            onValueChange={(operator) =>
+              update(index, {
+                ...rule,
+                operator: operator as LaneRule["operator"],
+              })
+            }
+          />
+          <Field
+            label={`Lane ${lane} rule ${index + 1} value`}
+            description={
+              rule.field === "path"
+                ? "Case-sensitive paths: src/**, **/*.tsx. * matches within a directory; ** matches directories. Renames use the new path."
+                : rule.field === "label"
+                  ? "Exact label name, ignoring case."
+                  : rule.field === "title"
+                    ? "Text to find in the title, ignoring case."
+                    : "Whole number, including zero."
+            }
+          >
+            <Input
+              required
+              maxLength={200}
+              disabled={disabled}
+              value={rule.value}
+              inputMode={rule.field === "files" ? "numeric" : "text"}
+              onValueChange={(text) => update(index, { ...rule, value: text })}
+            />
+          </Field>
+          <div>
+            <Button
+              disabled={disabled}
+              onClick={() =>
+                onChange({
+                  ...routing,
+                  rules: routing.rules.filter((_, i) => i !== index),
+                })
+              }
+            >
+              Remove rule {index + 1} from lane {lane}
+            </Button>
+          </div>
+        </div>
+      ))}
+      <div>
+        <Button
+          disabled={disabled || routing.rules.length >= 12}
+          onClick={() =>
+            onChange({
+              ...routing,
+              rules: [
+                ...routing.rules,
+                {
+                  id: crypto.randomUUID(),
+                  field: "title",
+                  operator: "contains",
+                  value: "",
+                },
+              ],
+            })
+          }
+        >
+          Add rule to lane {lane}
+        </Button>
+      </div>
+    </>
+  );
+}
diff --git a/src/bundled/review-configuration/README.md b/src/bundled/review-configuration/README.md
index 20e987d7a6..99332e6b6b 100644
--- a/src/bundled/review-configuration/README.md
+++ b/src/bundled/review-configuration/README.md
@@ -3,11 +3,14 @@
 An optional bundled plugin with a separate sidebar page for repository review
 settings. Enable **Review Configuration** in Settings → Plugins → Manage plugins.
 Choose a channel, register a GitHub repository, add named lanes, reviewer agents, and instructions,
-and save. The repository table supports editing and an explicit reload.
+and save. The repository table supports editing and an explicit reload. The page
+remembers your channel per identity/community and selects it automatically when
+only one eligible channel is available.
 
 Use **Submit PR** to select a saved repository, enter a PR number or URL, and
-choose one configured reviewer per lane. **Start review threads** saves the
-instruction snapshot, creates an overview and one thread per lane, and mentions
+load PR details to preview matching lanes, then choose one configured reviewer
+per matching lane. **Start review threads** saves the instruction snapshot,
+creates one thread per matching lane with no overview, and mentions
 each selected reviewer with the complete lane instructions. The list retains
 thread links and delivery status. Sending does not prove that an agent is running
 or reviewing. No model process or reminder timer is started by this plugin.
@@ -49,7 +52,7 @@ There is no new SQL migration or local-only settings store. Ordinary channel
 authorization applies: readers can see instructions, and members who can post
 can edit them. Configuration is scoped to a channel, not globally unique across
 the community. No GitHub credentials are stored or requested, and repository
-existence/access is not checked in this first slice.
+existence/access is checked when loading PR details for submission.
 
 Edits carry the revision that the form loaded in `prev`; the relay rejects a
 stale edit atomically. A failed or uncertain save keeps the draft. Copy any
@@ -77,7 +80,7 @@ Use a test channel. Saving does not activate any review automation.
 
 Reviewer choices come from the session’s shared agent inventory. Saved public keys
 remain visible and removable if an agent disappears or is archived. Unassigned
-lanes may be saved as drafts. Submission requires one available reviewer per lane,
+lanes may be saved as drafts. Submission requires one available reviewer per matching lane,
 verified ownership by the signed-in user, and existing channel membership. The
 outbox rechecks membership before publishing mentions. Agent ownership is checked
 from fresh signed profiles; archive evidence and shared agent choices must be
@@ -89,9 +92,12 @@ lab with registered identities alone cannot execute a review.
 One `buzz.review.submission` artifact per channel/repository/PR stores the selected
 reviewers, instructions, configuration revision, and message IDs. Repeating a PR
 returns that record; resubmission rounds are not implemented. The PR URL is
-validated against the repository, but GitHub existence, permissions, title and
-commit are not fetched. Reviewers are asked to verify the PR and report the exact
-commit they reviewed. This does not post a GitHub review or claim an approval.
+validated against the repository. GitHub title, labels, file count, changed paths,
+and base/head commits are read before preview and rechecked before submission.
+If they change, confirm the updated preview before sending. The reviewer is
+asked to report the exact commit reviewed; this does not pin their checkout.
+Earlier version-1 submissions retain their overview and original thread IDs for
+recovery. New version-2 submissions store only matching lanes and their threads. This does not post a GitHub review or claim an approval.
 
 Artifact create/CAS prevents competing submissions. A local profile identifier
 and Web Lock serialize delivery in the submitting profile; outbox recovery keeps
@@ -112,8 +118,25 @@ notice). Submission explicitly reads the current record and reviewer profiles,
 refreshes agent choices, and uses the outbox's per-message membership preflight.
 Reconnect introduces no new plugin reads.
 
-Try Submit PR → Start review threads → reload → Open a lane thread. Check that
+Try Submit PR → Load PR details → Start review threads → reload → Open a lane thread. Check that
 the PR, reviewer mention and complete instructions are present. Submit the same
 PR again: it must reuse the saved threads. Test interrupted delivery with Resume
 from the same browser profile. Reminders, review verdict tracking, GitHub status
 synchronization, and new review rounds remain future work.
+
+## Routing rules
+
+Each lane accepts up to 12 rules, combined with **Match all rules** or **Match any
+rule**. No rules matches every PR. A PR can match several lanes; zero matches
+prevents submission. Title contains/does-not-contain and exact label matching
+ignore case. File counts support inclusive minimum and maximum values. Paths are
+case-sensitive and relative to the repository: `*` and `?` match within a path
+segment, while `**` matches zero or more complete segments. `src/**/*.tsx` matches
+TSX files below `src`. A negative path rule matches only when no changed path
+matches. Renames use the new path.
+
+Desktop reads use the existing signed-in GitHub CLI. Browser reads use GitHub's
+public API without credentials, so private PRs and rate-limited requests need the
+desktop host. The reader rejects incomplete/changing metadata and supports at
+most 3,000 changed files and 100 labels; it never routes on a truncated file list.
+Metadata is fetched only on Load PR details and submission; there is no poller.
diff --git a/src/bundled/review-configuration/ReviewConfigurationPage.test.tsx b/src/bundled/review-configuration/ReviewConfigurationPage.test.tsx
index 496cf55ad1..cca08d3272 100644
--- a/src/bundled/review-configuration/ReviewConfigurationPage.test.tsx
+++ b/src/bundled/review-configuration/ReviewConfigurationPage.test.tsx
@@ -9,7 +9,10 @@ import type { EventData } from "../../features/relay/events";
 import { keypair, signed } from "../../features/relay/testing";
 import { ReviewConfigurationCommunity } from "./ReviewConfigurationPage";
 
-afterEach(cleanup);
+afterEach(() => {
+  cleanup();
+  localStorage.clear();
+});
 const channel = "11111111-1111-4111-8111-111111111111";
 function fixture() {
   const key = keypair();
@@ -45,6 +48,7 @@ function fixture() {
     return event.id;
   });
   const session = {
+    scope: "review-test-scope",
     agentChoices: {
       snapshot: () => choices,
       subscribe: (listener: () => void) => {
@@ -81,6 +85,10 @@ function fixture() {
     session,
     publish,
     snapshotRead,
+    setChannels(channels: ChannelSummary[]) {
+      list = { ...list, channels };
+      for (const listener of listeners) listener();
+    },
     failAgents() {
       choices = {
         ...choices,
@@ -361,3 +369,132 @@ it("refreshes failed agent and archive reads without discarding the draft", asyn
       .reviewers,
   ).toEqual(["a".repeat(64)]);
 });
+
+it("selects the only channel, remembers another selection, and scopes it to the session", async () => {
+  const test = fixture();
+  const view = render(<ReviewConfigurationCommunity session={test.session} />);
+  await screen.findByRole("button", { name: "Register repository" });
+  expect(localStorage.getItem("buzz.review.channel:review-test-scope")).toBe(
+    channel,
+  );
+  const second = "22222222-2222-4222-8222-222222222222";
+  act(() =>
+    test.setChannels([
+      { id: channel, name: "Reviews", channelType: "stream" } as ChannelSummary,
+      {
+        id: second,
+        name: "Other reviews",
+        channelType: "stream",
+      } as ChannelSummary,
+    ]),
+  );
+  const user = userEvent.setup();
+  await user.click(screen.getByRole("combobox", { name: "Review channel" }));
+  await user.click(
+    await screen.findByRole("option", { name: "Other reviews" }),
+  );
+  expect(localStorage.getItem("buzz.review.channel:review-test-scope")).toBe(
+    second,
+  );
+  view.unmount();
+  const restored = render(
+    <ReviewConfigurationCommunity session={test.session} />,
+  );
+  expect(
+    screen.getByRole("combobox", { name: "Review channel" }).textContent,
+  ).toContain("Other reviews");
+  restored.unmount();
+  render(
+    <ReviewConfigurationCommunity
+      session={{ ...test.session, scope: "another-scope" } as RelaySession}
+    />,
+  );
+  expect(
+    screen.queryByRole("button", { name: "Register repository" }),
+  ).toBeNull();
+  expect(localStorage.getItem("buzz.review.channel:review-test-scope")).toBe(
+    second,
+  );
+});
+
+it("saves path rules through field changes and preserves them after reload", async () => {
+  const test = fixture();
+  render(<ReviewConfigurationCommunity session={test.session} />);
+  const user = await openDraft();
+  await user.click(screen.getByRole("button", { name: "Add rule to lane 1" }));
+  await user.click(
+    screen.getByRole("combobox", { name: "Lane 1 rule 1 field" }),
+  );
+  await user.click(
+    await screen.findByRole("option", { name: "Changed file path" }),
+  );
+  await user.type(
+    screen.getByRole("textbox", { name: "Lane 1 rule 1 value" }),
+    "src/**/*.tsx",
+  );
+  await user.click(screen.getByRole("button", { name: "Save settings" }));
+  await screen.findByText(
+    "Saved example-org/project. Use Submit PR to start review threads.",
+  );
+  const saved = JSON.parse(test.publish.mock.calls[0]?.[0].content ?? "{}")
+    .lanes[0].routing;
+  expect(saved.rules[0]).toMatchObject({
+    field: "path",
+    operator: "matches",
+    value: "src/**/*.tsx",
+    id: expect.any(String),
+  });
+  await user.click(screen.getByRole("button", { name: "Reload" }));
+  await user.click(
+    await screen.findByRole("button", { name: "Edit example-org/project" }),
+  );
+  expect(
+    (
+      screen.getByRole("textbox", {
+        name: "Lane 1 rule 1 value",
+      }) as HTMLInputElement
+    ).value,
+  ).toBe("src/**/*.tsx");
+  await user.click(
+    screen.getByRole("button", { name: "Remove rule 1 from lane 1" }),
+  );
+  await user.click(screen.getByRole("button", { name: "Save settings" }));
+  await screen.findByText(
+    "Saved example-org/project. Use Submit PR to start review threads.",
+  );
+  expect(
+    JSON.parse(test.publish.mock.calls[1]?.[0].content ?? "{}").lanes[0].routing
+      .rules,
+  ).toEqual([]);
+});
+
+it("preserves the remembered channel until pending metadata finishes", async () => {
+  const test = fixture();
+  const second = "22222222-2222-4222-8222-222222222222";
+  localStorage.setItem("buzz.review.channel:review-test-scope", second);
+  test.setChannels([
+    { id: channel, name: "Reviews", channelType: "stream" } as ChannelSummary,
+    { id: second, metadataPending: true } as ChannelSummary,
+  ]);
+  render(<ReviewConfigurationCommunity session={test.session} />);
+  expect(localStorage.getItem("buzz.review.channel:review-test-scope")).toBe(
+    second,
+  );
+  act(() =>
+    test.setChannels([
+      { id: channel, name: "Reviews", channelType: "stream" } as ChannelSummary,
+      {
+        id: second,
+        name: "Remembered reviews",
+        channelType: "stream",
+      } as ChannelSummary,
+    ]),
+  );
+  await screen.findByRole("button", { name: "Register repository" });
+  expect(
+    screen.getByRole("combobox", { name: "Review channel" }).textContent,
+  ).toContain("Remembered reviews");
+  expect(localStorage.getItem("buzz.review.channel:review-test-scope")).toBe(
+    second,
+  );
+});
diff --git a/src/bundled/review-configuration/ReviewConfigurationPage.tsx b/src/bundled/review-configuration/ReviewConfigurationPage.tsx
index 82c3eef7cb..e123fdbe78 100644
--- a/src/bundled/review-configuration/ReviewConfigurationPage.tsx
+++ b/src/bundled/review-configuration/ReviewConfigurationPage.tsx
@@ -1,3 +1,6 @@
+import { createPullReader, type ReadPull } from "./pull-facts";
+const publicPullReader = createPullReader();
+import { LaneRules } from "./LaneRules";
 import { useEffect, useRef, useState, type ReactNode } from "react";
 import { useAgentChoices } from "../../features/agents/use-choices";
 import { ReviewSubmissions } from "./ReviewSubmissions";
@@ -52,9 +55,11 @@ function Frame({ children }: { children: ReactNode }) {
 export function ReviewConfigurationPage({
   relay,
   navigator,
+  readPull = publicPullReader,
 }: {
   relay: RelayData;
   navigator?: Navigation;
+  readPull?: ReadPull;
 }) {
   const connection = useRelayConnection(relay);
   if (connection.status === "ready")
@@ -62,6 +67,7 @@ export function ReviewConfigurationPage({
       <ReviewConfigurationCommunity
         key={`${connection.scope}:${connection.generation}`}
         session={connection.session}
+        readPull={readPull}
         onOpenThread={async (channelId, id) => {
           const scope = splitPartition(connection.scope ?? "");
           if (!navigator || !scope)
@@ -99,12 +105,21 @@ export function ReviewConfigurationPage({
 export function ReviewConfigurationCommunity({
   session,
   onOpenThread,
+  readPull = publicPullReader,
 }: {
   session: RelaySession;
+  readPull?: ReadPull;
   onOpenThread?: ((channel: string, id: string) => Promise<void>) | undefined;
 }) {
   const list = useChannelList(session.channels);
-  const [channel, setChannel] = useState("");
+  const selectionKey = `buzz.review.channel:${session.scope}`;
+  const [channel, setChannel] = useState(() => {
+    try {
+      return localStorage.getItem(selectionKey) ?? "";
+    } catch {
+      return "";
+    }
+  });
   const [editing, setEditing] = useState(false);
   const channels = list.channels.filter(
     (item) =>
@@ -114,6 +129,21 @@ export function ReviewConfigurationCommunity({
       !item.pending &&
       (item.channelType === "stream" || item.channelType === "forum"),
   );
+  useEffect(() => {
+    if (list.status !== "ready" || list.coverage === "partial" || editing)
+      return;
+    if (list.channels.some((item) => item.metadataPending)) return;
+    if (channel && channels.some((item) => item.id === channel)) return;
+    setChannel(channels.length === 1 ? (channels[0]?.id ?? "") : "");
+  }, [list.status, list.coverage, list.channels, channels, channel, editing]);
+  useEffect(() => {
+    try {
+      if (channel) localStorage.setItem(selectionKey, channel);
+      else localStorage.removeItem(selectionKey);
+    } catch {
+      /* Storage may be unavailable; selection still works for this visit. */
+    }
+  }, [selectionKey, channel]);
   const selected = channels.find((item) => item.id === channel);
   const writable =
     !!selected &&
@@ -164,6 +194,7 @@ export function ReviewConfigurationCommunity({
           writable={writable}
           onEditingChange={setEditing}
           onOpenThread={onOpenThread}
+          readPull={readPull}
         />
       )}
     </Frame>
@@ -176,8 +207,10 @@ function ChannelConfiguration({
   writable,
   onEditingChange,
   onOpenThread,
+  readPull,
 }: {
   session: RelaySession;
+  readPull: ReadPull;
   channel: string;
   writable: boolean;
   onEditingChange: (editing: boolean) => void;
@@ -365,6 +398,7 @@ function ChannelConfiguration({
         writable={writable}
         onEditingChange={setSubmitting}
         onOpenThread={onOpenThread}
+        readPull={readPull}
       />
     </>
   );
@@ -544,6 +578,19 @@ function ConfigurationEditor({
                 }
               />
             </Field>
+            <LaneRules
+              lane={index + 1}
+              value={lane.routing}
+              disabled={busy}
+              onChange={(routing) =>
+                setDraft({
+                  ...draft,
+                  lanes: draft.lanes.map((item) =>
+                    item.id === lane.id ? { ...item, routing } : item,
+                  ),
+                })
+              }
+            />
             <LaneReviewers
               lane={index + 1}
               reviewers={lane.reviewers}
diff --git a/src/bundled/review-configuration/ReviewSubmissions.test.tsx b/src/bundled/review-configuration/ReviewSubmissions.test.tsx
index e8e65af8ee..349d600273 100644
--- a/src/bundled/review-configuration/ReviewSubmissions.test.tsx
+++ b/src/bundled/review-configuration/ReviewSubmissions.test.tsx
@@ -68,3 +68,99 @@ it("waits for list reads before offering submission and restores trigger focus o
   await user.click(screen.getByRole("button", { name: "Cancel" }));
   expect(document.activeElement).toBe(submit);
 });
+
+it("clears changed PR previews, blocks unmatched lanes, and rechecks facts before any write", async () => {
+  const { vi } = await import("vitest");
+  const choices = {
+    pending: false,
+    selectable: [{ pubkey: "a".repeat(64), name: "Reviewer" }],
+    archives: { status: "ready" },
+  };
+  const snapshotRead = vi.fn(async () => []);
+  const publish = vi.fn();
+  const session = {
+    snapshotRead,
+    configArtifactWriter: { publish },
+    agentChoices: {
+      subscribe: () => () => {},
+      snapshot: () => choices,
+      retain: () => () => {},
+      ensure() {},
+    },
+  } as unknown as RelaySession;
+  const configuration: SavedReviewConfig = {
+    revision: "b".repeat(64),
+    artifactId: "config",
+    config: {
+      version: 1,
+      repository: "example-org/project",
+      reminderMinutes: 15,
+      lanes: [
+        {
+          id: "ui",
+          name: "UI",
+          instructions: "Check keyboard navigation.",
+          reviewers: ["a".repeat(64)],
+          routing: {
+            mode: "all",
+            rules: [
+              { id: "ui", field: "title", operator: "contains", value: "UI" },
+            ],
+          },
+        },
+      ],
+    },
+  };
+  const facts = {
+    repository: "example-org/project",
+    pr: 42,
+    title: "Improve UI",
+    labels: [],
+    changedFiles: 1,
+    paths: ["src/ui.tsx"],
+    head: "a".repeat(40),
+    base: "b".repeat(40),
+  };
+  const readPull = vi.fn(async () => facts);
+  render(
+    <ReviewSubmissions
+      session={session}
+      channel="channel"
+      configurations={[configuration]}
+      disabled={false}
+      writable
+      onEditingChange={() => {}}
+      readPull={readPull}
+    />,
+  );
+  const user = userEvent.setup();
+  await act(async () => {});
+  await user.click(screen.getByRole("button", { name: "Submit PR" }));
+  const input = screen.getByRole("textbox", { name: "Pull request" });
+  const start = screen.getByRole("button", {
+    name: "Start review threads",
+  }) as HTMLButtonElement;
+  await user.type(input, "42");
+  expect(start.disabled).toBe(true);
+  await user.click(screen.getByRole("button", { name: "Load PR details" }));
+  await screen.findByText("Matching lanes: UI");
+  expect(start.disabled).toBe(false);
+  await user.type(input, "3");
+  expect(start.disabled).toBe(true);
+  expect(screen.queryByText("Matching lanes: UI")).toBeNull();
+  await user.clear(input);
+  await user.type(input, "42");
+  readPull.mockResolvedValueOnce({ ...facts, title: "Backend change" });
+  await user.click(screen.getByRole("button", { name: "Load PR details" }));
+  await screen.findByText(/Matching lanes: None/);
+  expect(start.disabled).toBe(true);
+  await user.click(screen.getByRole("button", { name: "Load PR details" }));
+  await screen.findByText("Matching lanes: UI");
+  readPull.mockResolvedValueOnce({ ...facts, head: "c".repeat(40) });
+  await user.click(start);
+  expect((await screen.findByRole("alert")).textContent).toContain(
+    "The PR changed",
+  );
+  expect(publish).not.toHaveBeenCalled();
+  expect(snapshotRead).toHaveBeenCalledTimes(1);
+});
diff --git a/src/bundled/review-configuration/ReviewSubmissions.tsx b/src/bundled/review-configuration/ReviewSubmissions.tsx
index 5fb289638c..e0b724b197 100644
--- a/src/bundled/review-configuration/ReviewSubmissions.tsx
+++ b/src/bundled/review-configuration/ReviewSubmissions.tsx
@@ -1,6 +1,10 @@
-import { useEffect, useRef, useState } from "react";
+import { createPullReader, pullFingerprint, type ReadPull } from "./pull-facts";
+import { laneMatches, type PullFacts } from "./routing";
+const publicPullReader = createPullReader();
+import { useEffect, useMemo, useRef, useState } from "react";
 import { useAgentChoices } from "../../features/agents/use-choices";
 import type { RelaySession } from "../../features/relay/session";
+import { Accordion } from "../../shared/design-system/ui/Accordion";
 import { Button } from "../../shared/design-system/ui/Button";
 import { Field } from "../../shared/design-system/ui/Field";
 import { InlineHeader } from "../../shared/design-system/ui/Header";
@@ -12,6 +16,8 @@ import {
   loadSubmissions,
   prUrl,
   submitReview,
+  submissionLane,
+  pullRequest,
   type SavedSubmission,
 } from "./submissions";
 
@@ -23,8 +29,10 @@ export function ReviewSubmissions({
   writable,
   onEditingChange,
   onOpenThread,
+  readPull = publicPullReader,
 }: {
   session: RelaySession;
+  readPull?: ReadPull;
   channel: string;
   configurations: readonly SavedReviewConfig[];
   disabled: boolean;
@@ -78,19 +86,13 @@ export function ReviewSubmissions({
   }, [session, channel, reload]);
   return (
     <section className="review-config-form" aria-label="PR submissions">
-      <InlineHeader title="PR submissions" />
+      <InlineHeader title="Submit a PR" />
       <p>
         Submit a PR to start reviewer conversations using saved settings.
         Delivery does not confirm that a reviewer is running. Automatic
         reminders are off.
       </p>
       <div className="review-config-actions">
-        <Button
-          disabled={disabled || !!draft || loading}
-          onClick={() => setReload((value) => value + 1)}
-        >
-          Reload submissions
-        </Button>
         <Button
           variant="prominent"
           disabled={
@@ -109,11 +111,6 @@ export function ReviewSubmissions({
           Submit PR
         </Button>
       </div>
-      {loading && <p role="status">Loading submissions…</p>}
-      {error && (
-        <p role="alert">{error} Use Reload submissions to try again.</p>
-      )}
-      {warning && <p role="alert">{warning}</p>}
       {draft && (
         <SubmissionForm
           key={draft.existing?.artifactId ?? "new"}
@@ -121,6 +118,7 @@ export function ReviewSubmissions({
           channel={channel}
           configurations={configurations}
           initial={draft.config}
+          readPull={readPull}
           existing={draft.existing}
           writable={writable}
           onClose={() => setDraft(undefined)}
@@ -132,85 +130,109 @@ export function ReviewSubmissions({
           }
         />
       )}
-      {!loading && !error && !rows.length && (
-        <p>No PRs submitted in this channel.</p>
-      )}
-      {rows.map((row) => (
-        <section
-          key={row.artifactId}
-          className="review-config-lane"
-          aria-label={`${row.value.config.repository}#${row.value.pr}`}
-        >
-          <InlineHeader
-            title={`${row.value.config.repository}#${row.value.pr}`}
-          />
-          <p>{prUrl(row.value)}</p>
-          {row.value.threads.map((thread, index) => (
-            <div
-              key={
-                index === 0
-                  ? "overview"
-                  : (row.value.config.lanes[index - 1]?.id ?? index)
-              }
-              className="review-config-actions"
-            >
-              <span>
-                {index === 0
-                  ? "Overview"
-                  : row.value.config.lanes[index - 1]?.name}
-                :{" "}
-                {thread.delivered
-                  ? "Request delivered"
-                  : thread.id || thread.started
-                    ? "Delivery unconfirmed"
-                    : "Not sent"}
+      <section className="review-config-form" aria-label="Existing PRs">
+        <InlineHeader title="Existing PRs" />
+        <div>
+          <Button
+            disabled={disabled || !!draft || loading}
+            onClick={() => setReload((value) => value + 1)}
+          >
+            Reload submissions
+          </Button>
+        </div>
+        {loading && <p role="status">Loading submissions…</p>}
+        {error && (
+          <p role="alert">{error} Use Reload submissions to try again.</p>
+        )}
+        {warning && <p role="alert">{warning}</p>}
+        {!loading && !error && !rows.length && (
+          <p>No PRs submitted in this channel.</p>
+        )}
+        <Accordion
+          variant="form"
+          items={rows.map((row) => ({
+            value: row.artifactId,
+            title: (
+              <span className="review-config-pr-summary">
+                <span>
+                  {row.value.config.repository}#{row.value.pr}
+                </span>
+                <span className="text-caption text-subtle">
+                  {row.value.threads.every((thread) => thread.delivered)
+                    ? "Requests delivered"
+                    : "Delivery incomplete"}
+                </span>
               </span>
-              {thread.id && (
-                <Button
-                  disabled={!onOpenThread || !!draft || disabled}
-                  onClick={async () => {
-                    try {
-                      if (thread.id) await onOpenThread?.(channel, thread.id);
-                    } catch (reason) {
-                      setError(
-                        reason instanceof Error
-                          ? reason.message
-                          : "Could not open thread.",
-                      );
-                    }
-                  }}
-                >
-                  Open{" "}
-                  {index === 0
-                    ? "overview"
-                    : row.value.config.lanes[index - 1]?.name}{" "}
-                  thread
-                </Button>
-              )}
-            </div>
-          ))}
-          {!row.value.threads.every((thread) => thread.delivered) && (
-            <div>
-              <Button
-                disabled={disabled || loading || !!draft || !writable}
-                onClick={(event) => {
-                  trigger.current = event.currentTarget;
-                  setDraft({
-                    config: {
-                      config: row.value.config,
-                      revision: row.value.configRevision,
-                      artifactId: "",
-                    },
-                    existing: row,
-                  });
-                }}
+            ),
+            content: (
+              <section
+                className="review-config-lane"
+                aria-label={`${row.value.config.repository}#${row.value.pr}`}
               >
-                Resume submission
-              </Button>
-            </div>
-          )}
-        </section>
-      ))}
+                <p>{prUrl(row.value)}</p>
+                {row.value.threads.map((thread, index) => (
+                  <div
+                    key={submissionLane(row.value, index)?.id ?? "overview"}
+                    className="review-config-actions"
+                  >
+                    <span>
+                      {submissionLane(row.value, index)?.name ??
+                        "Overview (earlier submission)"}
+                      :{" "}
+                      {thread.delivered
+                        ? "Request delivered"
+                        : thread.id || thread.started
+                          ? "Delivery unconfirmed"
+                          : "Not sent"}
+                    </span>
+                    {thread.id && (
+                      <Button
+                        disabled={!onOpenThread || !!draft || disabled}
+                        onClick={async () => {
+                          try {
+                            if (thread.id)
+                              await onOpenThread?.(channel, thread.id);
+                          } catch (reason) {
+                            setError(
+                              reason instanceof Error
+                                ? reason.message
+                                : "Could not open thread.",
+                            );
+                          }
+                        }}
+                      >
+                        Open{" "}
+                        {submissionLane(row.value, index)?.name ?? "overview"}{" "}
+                        thread
+                      </Button>
+                    )}
+                  </div>
+                ))}
+                {!row.value.threads.every((thread) => thread.delivered) && (
+                  <div>
+                    <Button
+                      disabled={disabled || loading || !!draft || !writable}
+                      onClick={(event) => {
+                        trigger.current = event.currentTarget;
+                        setDraft({
+                          config: {
+                            config: row.value.config,
+                            revision: row.value.configRevision,
+                            artifactId: "",
+                          },
+                          existing: row,
+                        });
+                      }}
+                    >
+                      Resume submission
+                    </Button>
+                  </div>
+                )}
+              </section>
+            ),
+          }))}
+        />
+      </section>
     </section>
   );
 }
@@ -224,8 +246,10 @@ function SubmissionForm({
   writable,
   onClose,
   onProgress,
+  readPull,
 }: {
   session: RelaySession;
+  readPull: ReadPull;
   channel: string;
   configurations: readonly SavedReviewConfig[];
   initial: SavedReviewConfig;
@@ -240,11 +264,44 @@ function SubmissionForm({
   const [reviewers, setReviewers] = useState(
     initial.config.lanes.map((lane) => lane.reviewers[0] ?? ""),
   );
+  const [facts, setFacts] = useState<PullFacts>();
+  const matched = useMemo(
+    () =>
+      config.config.lanes.map(
+        (lane) => !!facts && laneMatches(lane.routing, facts),
+      ),
+    [config.config.lanes, facts],
+  );
+  const [reading, setReading] = useState(false);
   const [busy, setBusy] = useState(false);
   const [error, setError] = useState("");
   const [started, setStarted] = useState(!!existing);
   const operation = useRef<AbortController | undefined>(undefined);
   useEffect(() => () => operation.current?.abort(), []);
+  async function preview() {
+    if (operation.current) return;
+    const controller = new AbortController();
+    operation.current = controller;
+    setReading(true);
+    setFacts(undefined);
+    setError("");
+    try {
+      const next = await readPull(
+        config.config.repository,
+        pullRequest(pr, config.config.repository),
+        AbortSignal.any([controller.signal, AbortSignal.timeout(60_000)]),
+      );
+      if (!controller.signal.aborted) setFacts(next);
+    } catch (reason) {
+      if (!controller.signal.aborted)
+        setError(
+          reason instanceof Error ? reason.message : "Could not load PR.",
+        );
+    } finally {
+      operation.current = undefined;
+      if (!controller.signal.aborted) setReading(false);
+    }
+  }
   async function submit() {
     if (operation.current || !writable) return;
     const controller = new AbortController();
@@ -253,6 +310,21 @@ function SubmissionForm({
     setError("");
     let recorded = started;
     try {
+      if (!started) {
+        if (!facts)
+          throw new Error("Load PR details to preview matching lanes first.");
+        const current = await readPull(
+          config.config.repository,
+          pullRequest(pr, config.config.repository),
+          AbortSignal.any([controller.signal, AbortSignal.timeout(60_000)]),
+        );
+        if (pullFingerprint(current) !== pullFingerprint(facts)) {
+          setFacts(current);
+          throw new Error(
+            "The PR changed. Review the updated matching lanes before starting threads.",
+          );
+        }
+      }
       await submitReview(
         session,
         channel,
@@ -277,6 +349,7 @@ function SubmissionForm({
           }
         },
         started,
+        facts,
       );
       if (!controller.signal.aborted) onClose();
     } catch (reason) {
@@ -305,7 +378,7 @@ function SubmissionForm({
           label="Repository to review"
           variant="field"
           value={config.config.repository}
-          disabled={busy || started}
+          disabled={busy || reading || started}
           groups={[
             {
               label: "Repositories",
@@ -320,6 +393,7 @@ function SubmissionForm({
               (item) => item.config.repository === repository,
             );
             if (row) {
+              setFacts(undefined);
               setConfig(row);
               setReviewers(
                 row.config.lanes.map((lane) => lane.reviewers[0] ?? ""),
@@ -329,7 +403,7 @@ function SubmissionForm({
         />
         <Field
           label="Pull request"
-          description="PR number or full GitHub PR URL. The reviewer verifies the PR and current commit; Buzz does not fetch GitHub metadata here."
+          description="Enter a PR number or full GitHub PR URL, then load its details to preview matching lanes."
         >
           <Input
             autoFocus
@@ -337,66 +411,113 @@ function SubmissionForm({
             maxLength={300}
             placeholder="https://github.com/example-org/project/pull/123"
             value={pr}
-            disabled={busy || started}
-            onValueChange={setPr}
+            disabled={busy || reading || started}
+            onValueChange={(value) => {
+              setPr(value);
+              setFacts(undefined);
+            }}
           />
         </Field>
       </SettingsGroup>
-      {config.config.lanes.map((lane, index) => (
-        <section key={lane.id} className="review-config-lane">
-          <Select
-            variant="field"
-            label={`${lane.name} reviewer`}
-            value={reviewers[index] ?? ""}
-            required
-            disabled={busy || started}
-            placeholder="Choose a reviewer"
-            groups={[
-              {
-                label: "Configured reviewers",
-                options: lane.reviewers.map((key) => {
-                  const choice = choices.selectable.find(
-                    (item) => item.pubkey === key,
-                  );
-                  return {
-                    value: key,
-                    label:
-                      choice?.managedName ??
-                      choice?.name ??
-                      `Unavailable (${key.slice(0, 10)})`,
-                    disabled: !choice,
-                  };
-                }),
-              },
-            ]}
-            onValueChange={(value) =>
-              setReviewers((current) =>
-                current.map((item, i) => (i === index ? value : item)),
-              )
-            }
-          />
-          <details>
-            <summary>Instructions for {lane.name}</summary>
-            <p className="review-config-instructions">{lane.instructions}</p>
-          </details>
-        </section>
-      ))}
+      {!started && (
+        <div className="review-config-form">
+          <div>
+            <Button
+              disabled={busy || reading || !pr.trim()}
+              loading={reading}
+              onClick={() => void preview()}
+            >
+              Load PR details
+            </Button>
+          </div>
+          {facts && (
+            <>
+              <p>
+                {facts.title} · {facts.changedFiles} changed files · Labels:{" "}
+                {facts.labels.join(", ") || "none"}
+              </p>
+              <p>
+                Matching lanes:{" "}
+                {config.config.lanes
+                  .filter((_, index) => matched[index])
+                  .map((lane) => lane.name)
+                  .join(", ") ||
+                  "None. Adjust the lane rules before submitting."}
+              </p>
+              <p>
+                Other lanes:{" "}
+                {config.config.lanes
+                  .filter((_, index) => !matched[index])
+                  .map((lane) => lane.name)
+                  .join(", ") || "none"}
+              </p>
+            </>
+          )}
+        </div>
+      )}
+      {config.config.lanes.map((lane, index) =>
+        !started && !matched[index] ? null : (
+          <section key={lane.id} className="review-config-lane">
+            <Select
+              variant="field"
+              label={`${lane.name} reviewer`}
+              value={reviewers[index] ?? ""}
+              required
+              disabled={busy || reading || started}
+              placeholder="Choose a reviewer"
+              groups={[
+                {
+                  label: "Configured reviewers",
+                  options: lane.reviewers.map((key) => {
+                    const choice = choices.selectable.find(
+                      (item) => item.pubkey === key,
+                    );
+                    return {
+                      value: key,
+                      label:
+                        choice?.managedName ??
+                        choice?.name ??
+                        `Unavailable (${key.slice(0, 10)})`,
+                      disabled: !choice,
+                    };
+                  }),
+                },
+              ]}
+              onValueChange={(value) =>
+                setReviewers((current) =>
+                  current.map((item, i) => (i === index ? value : item)),
+                )
+              }
+            />
+            <details>
+              <summary>Instructions for {lane.name}</summary>
+              <p className="review-config-instructions">{lane.instructions}</p>
+            </details>
+          </section>
+        ),
+      )}
       <p>
-        This sends a request to one reviewer per lane in this channel. Reviewers
-        must belong to your signed-in identity and already have channel access.
-        Their model runner must be connected to reply.
+        This sends a request to one reviewer per matching lane in this channel,
+        with no extra overview thread. Reviewers must belong to your signed-in
+        identity and already have channel access. Their model runner must be
+        connected to reply.
       </p>
       {error && <p role="alert">{error}</p>}
       {busy && <p role="status">Saving submission and delivering threads…</p>}
       <div className="review-config-actions">
-        <Button disabled={busy} onClick={onClose}>
+        <Button disabled={busy || reading} onClick={onClose}>
           {started ? "Close" : "Cancel"}
         </Button>
         <Button
           type="submit"
           variant="prominent"
           loading={busy}
-          disabled={!writable || choices.pending}
+          disabled={
+            !writable ||
+            choices.pending ||
+            reading ||
+            (!started && (!facts || !matched.some(Boolean)))
+          }
         >
           {started ? "Resume delivery" : "Start review threads"}
         </Button>
diff --git a/src/bundled/review-configuration/configuration.ts b/src/bundled/review-configuration/configuration.ts
index dd2e23fbf5..eebb24e522 100644
--- a/src/bundled/review-configuration/configuration.ts
+++ b/src/bundled/review-configuration/configuration.ts
@@ -1,3 +1,4 @@
+import { validateRouting, type LaneRouting } from "./routing";
 import {
   ARTIFACT_KIND,
   uuidv5,
@@ -11,6 +12,7 @@ export type ReviewLane = Readonly<{
   name: string;
   instructions: string;
   reviewers: readonly string[];
+  routing?: LaneRouting;
 }>;
 export type ReviewConfig = Readonly<{
   version: 1;
@@ -95,6 +97,9 @@ export function validateConfig(value: unknown): ReviewConfig {
       name,
       instructions: lane.instructions.trim(),
       reviewers: reviewers as string[],
+      ...(lane.routing === undefined
+        ? {}
+        : { routing: validateRouting(lane.routing) }),
     };
   });
   const config: ReviewConfig = {
diff --git a/src/bundled/review-configuration/index.tsx b/src/bundled/review-configuration/index.tsx
index 5e8312d6aa..9bfd296376 100644
--- a/src/bundled/review-configuration/index.tsx
+++ b/src/bundled/review-configuration/index.tsx
@@ -1,9 +1,12 @@
+import { gitHubCli } from "../github/gh";
+import { createPullReader } from "./pull-facts";
 import type { PluginModule } from "../../plugins/api";
 import { ReviewConfigurationPage } from "./ReviewConfigurationPage";
 
-export const inject = ["pages", "relay", "navigation"];
+export const inject = ["pages", "relay", "navigation", "host"];
 export const apply: PluginModule["apply"] = (ctx) => {
   const { relay, navigation: navigator } = ctx;
+  const readPull = createPullReader(gitHubCli(ctx.host));
   ctx.pages.register({
     id: "configuration",
     title: "Review Configuration",
@@ -11,7 +14,11 @@ export const apply: PluginModule["apply"] = (ctx) => {
     primary: true,
     placement: "sidebar",
     component: () => (
-      <ReviewConfigurationPage relay={relay} navigator={navigator} />
+      <ReviewConfigurationPage
+        relay={relay}
+        navigator={navigator}
+        readPull={readPull}
+      />
     ),
   });
 };
diff --git a/src/bundled/review-configuration/manifest.json b/src/bundled/review-configuration/manifest.json
index 26d514abfe..5725d4bd68 100644
--- a/src/bundled/review-configuration/manifest.json
+++ b/src/bundled/review-configuration/manifest.json
@@ -3,5 +3,17 @@
   "name": "Review Configuration",
   "apiVersion": 1,
   "description": "Save repository and lane settings for review workflows.",
-  "discovery": { "category": "productivity", "tags": ["code", "tasks"] }
+  "discovery": {
+    "category": "productivity",
+    "tags": ["code", "tasks"]
+  },
+  "host": {
+    "processes": [
+      {
+        "id": "graphql",
+        "program": "gh",
+        "args": ["api", "graphql", "--hostname", "github.com", "--input", "-"]
+      }
+    ]
+  }
 }
diff --git a/src/bundled/review-configuration/pull-facts.test.ts b/src/bundled/review-configuration/pull-facts.test.ts
new file mode 100644
index 0000000000..2912cbad08
--- /dev/null
+++ b/src/bundled/review-configuration/pull-facts.test.ts
@@ -0,0 +1,121 @@
+import { afterEach, expect, it, vi } from "vitest";
+import { createPullReader } from "./pull-facts";
+import { GhUnavailable, type GitHubCli } from "../github/gh";
+const signal = () => new AbortController().signal;
+const repository = "example-org/project";
+const metadata = {
+  title: "Fix auth",
+  head: { sha: "a".repeat(40) },
+  base: { sha: "b".repeat(40) },
+  changed_files: 2,
+  labels: [{ name: "security" }],
+};
+const answer = (paths: string[], hasNextPage = false) => ({
+  repository: {
+    pullRequest: {
+      title: metadata.title,
+      headRefOid: metadata.head.sha,
+      baseRefOid: metadata.base.sha,
+      changedFiles: 2,
+      labels: { nodes: metadata.labels, pageInfo: { hasNextPage: false } },
+      files: {
+        nodes: paths.map((path) => ({ path })),
+        pageInfo: { hasNextPage, endCursor: hasNextPage ? "next" : null },
+      },
+    },
+  },
+});
+afterEach(() => vi.unstubAllGlobals());
+it("loads all file pages and labels through the existing authenticated client", async () => {
+  const gh = vi
+    .fn()
+    .mockResolvedValueOnce(answer(["src/a.ts"], true))
+    .mockResolvedValueOnce(answer(["src/b.ts"]));
+  const facts = await createPullReader(gh as GitHubCli)(
+    repository,
+    12,
+    signal(),
+  );
+  expect(facts.paths).toEqual(["src/a.ts", "src/b.ts"]);
+  expect(facts.labels).toEqual(["security"]);
+  expect(gh.mock.calls[1]?.[1]).toMatchObject({
+    owner: "example-org",
+    name: "project",
+    pr: 12,
+    cursor: "next",
+  });
+});
+it("rejects incomplete file lists, duplicate pages, incomplete labels and changed heads", async () => {
+  const incompleteLabels = answer(["a", "b"]);
+  incompleteLabels.repository.pullRequest.labels.pageInfo.hasNextPage = true;
+  const changed = answer(["b"]);
+  changed.repository.pullRequest.headRefOid = "c".repeat(40);
+  for (const replies of [
+    [answer(["a"])],
+    [answer(["a"], true), answer(["a"])],
+    [incompleteLabels],
+    [answer(["a"], true), changed],
+  ]) {
+    const gh = vi.fn();
+    for (const reply of replies) gh.mockResolvedValueOnce(reply);
+    await expect(
+      createPullReader(gh as GitHubCli)(repository, 12, signal()),
+    ).rejects.toThrow();
+  }
+});
+it("uses public reads when desktop processes are unavailable and verifies metadata again", async () => {
+  const fetcher = vi
+    .fn()
+    .mockResolvedValueOnce(Response.json(metadata))
+    .mockResolvedValueOnce(
+      Response.json([{ filename: "a" }, { filename: "b" }]),
+    )
+    .mockResolvedValueOnce(Response.json(metadata));
+  vi.stubGlobal("fetch", fetcher);
+  const gh = vi.fn().mockRejectedValue(new GhUnavailable("browser"));
+  const facts = await createPullReader(gh as GitHubCli)(
+    repository,
+    12,
+    signal(),
+  );
+  expect(facts.paths).toEqual(["a", "b"]);
+  expect(fetcher).toHaveBeenCalledTimes(3);
+  expect(fetcher.mock.calls[0]?.[1]).toMatchObject({
+    credentials: "omit",
+    signal: expect.any(AbortSignal),
+  });
+});
+it("does not route a public snapshot changed during file pagination", async () => {
+  vi.stubGlobal(
+    "fetch",
+    vi
+      .fn()
+      .mockResolvedValueOnce(Response.json(metadata))
+      .mockResolvedValueOnce(
+        Response.json([{ filename: "a" }, { filename: "b" }]),
+      )
+      .mockResolvedValueOnce(Response.json({ ...metadata, labels: [] })),
+  );
+  await expect(createPullReader()(repository, 12, signal())).rejects.toThrow(
+    "PR changed",
+  );
+});
+it("stops at API errors, cancellation and the file limit", async () => {
+  const fetcher = vi.fn().mockResolvedValue(new Response("", { status: 404 }));
+  vi.stubGlobal("fetch", fetcher);
+  await expect(createPullReader()(repository, 12, signal())).rejects.toThrow(
+    "private or unavailable",
+  );
+  fetcher.mockResolvedValueOnce(
+    Response.json({ ...metadata, changed_files: 3001 }),
+  );
+  await expect(createPullReader()(repository, 12, signal())).rejects.toThrow(
+    "3,000",
+  );
+  const controller = new AbortController();
+  controller.abort();
+  await expect(
+    createPullReader()(repository, 12, controller.signal),
+  ).rejects.toThrow();
+  expect(fetcher).toHaveBeenCalledTimes(2);
+});
diff --git a/src/bundled/review-configuration/pull-facts.ts b/src/bundled/review-configuration/pull-facts.ts
new file mode 100644
index 0000000000..0e5ce18f65
--- /dev/null
+++ b/src/bundled/review-configuration/pull-facts.ts
@@ -0,0 +1,183 @@
+import { GhUnavailable, type GitHubCli } from "../github/gh";
+import { repositoryName } from "./configuration";
+import type { PullFacts } from "./routing";
+export type ReadPull = (
+  repository: string,
+  pr: number,
+  signal: AbortSignal,
+) => Promise<PullFacts>;
+const MAX_FILES = 3000;
+const QUERY = `query($owner:String!,$name:String!,$pr:Int!,$cursor:String){
+ repository(owner:$owner,name:$name){pullRequest(number:$pr){
+ title headRefOid baseRefOid changedFiles
+ labels(first:100){nodes{name} pageInfo{hasNextPage}}
+ files(first:100,after:$cursor){nodes{path} pageInfo{hasNextPage endCursor}}
+ }}}`;
+type Pull = {
+  title: string;
+  headRefOid: string;
+  baseRefOid: string;
+  changedFiles: number;
+  labels: { nodes: { name: string }[]; pageInfo: { hasNextPage: boolean } };
+  files: {
+    nodes: { path: string }[];
+    pageInfo: { hasNextPage: boolean; endCursor: string | null };
+  };
+};
+function checked(facts: PullFacts): PullFacts {
+  if (
+    typeof facts.title !== "string" ||
+    facts.title.length > 2000 ||
+    !/^[0-9a-f]{40,64}$/i.test(facts.head) ||
+    !/^[0-9a-f]{40,64}$/i.test(facts.base) ||
+    !Number.isSafeInteger(facts.changedFiles) ||
+    facts.changedFiles < 0 ||
+    facts.changedFiles > MAX_FILES ||
+    !Array.isArray(facts.labels) ||
+    facts.labels.some(
+      (label) => typeof label !== "string" || label.length > 200,
+    ) ||
+    !Array.isArray(facts.paths) ||
+    facts.paths.some(
+      (path) => typeof path !== "string" || !path || path.length > 4096,
+    )
+  )
+    throw new Error(
+      "GitHub returned incomplete or unsupported PR data. Routing supports up to 3,000 changed files.",
+    );
+  return facts;
+}
+export function pullFingerprint(value: PullFacts) {
+  return JSON.stringify([
+    value.repository,
+    value.pr,
+    value.title,
+    [...value.labels].sort(),
+    value.changedFiles,
+    value.head,
+    value.base,
+    [...value.paths].sort(),
+  ]);
+}
+function assertComplete(facts: PullFacts) {
+  checked(facts);
+  if (
+    new Set(facts.paths).size !== facts.changedFiles ||
+    facts.paths.length !== facts.changedFiles
+  )
+    throw new Error(
+      "GitHub did not return the complete changed-file list. No review requests were sent.",
+    );
+  return facts;
+}
+function stable(a: PullFacts, b: PullFacts) {
+  if (
+    pullFingerprint({ ...a, paths: [] }) !==
+    pullFingerprint({ ...b, paths: [] })
+  )
+    throw new Error(
+      "The PR changed while it was being read. Load it again before routing.",
+    );
+}
+async function graphql(
+  gh: GitHubCli,
+  repository: string,
+  pr: number,
+  signal: AbortSignal,
+) {
+  const [owner, name] = repository.split("/");
+  let cursor: string | null = null;
+  let first: PullFacts | undefined;
+  const paths: string[] = [];
+  const cursors = new Set<string>();
+  for (let page = 0; page < 30; page++) {
+    signal.throwIfAborted();
+    const result: { repository: { pullRequest: Pull | null } | null } =
+      await gh(QUERY, { owner, name, pr, cursor }, signal);
+    const pull = result.repository?.pullRequest;
+    if (!pull)
+      throw new Error("This PR is unavailable to your GitHub account.");
+    if (pull.labels.pageInfo.hasNextPage)
+      throw new Error(
+        "This PR has more than 100 labels. Routing requires a complete label list.",
+      );
+    const facts = checked({
+      repository,
+      pr,
+      title: pull.title,
+      head: pull.headRefOid,
+      base: pull.baseRefOid,
+      changedFiles: pull.changedFiles,
+      labels: pull.labels.nodes.map((item) => item.name),
+      paths: pull.files.nodes.map((item) => item.path),
+    });
+    if (first) stable(first, facts);
+    else first = facts;
+    paths.push(...facts.paths);
+    if (!pull.files.pageInfo.hasNextPage)
+      return assertComplete({ ...first, paths });
+    cursor = pull.files.pageInfo.endCursor;
+    if (!cursor || cursors.has(cursor))
+      throw new Error("GitHub returned an invalid file-page cursor.");
+    cursors.add(cursor);
+  }
+  throw new Error("This PR exceeds the routing file limit.");
+}
+async function publicRead(repository: string, pr: number, signal: AbortSignal) {
+  const endpoint = `https://api.github.com/repos/${repository}/pulls/${pr}`;
+  async function read(url: string) {
+    const response = await fetch(url, {
+      signal,
+      credentials: "omit",
+      headers: { Accept: "application/vnd.github+json" },
+    });
+    if (!response.ok)
+      throw new Error(
+        response.status === 404
+          ? "This PR is private or unavailable. Use the desktop app with gh signed in for private PRs."
+          : response.status === 403 || response.status === 429
+            ? "GitHub's public API limit was reached. Try later or use the desktop app with gh signed in."
+            : `GitHub could not load this PR (${response.status}).`,
+      );
+    return response.json();
+  }
+  const metadata = async (): Promise<PullFacts> => {
+    const pull = await read(endpoint);
+    return checked({
+      repository,
+      pr,
+      title: pull.title,
+      head: pull.head?.sha,
+      base: pull.base?.sha,
+      changedFiles: pull.changed_files,
+      labels: pull.labels?.map((label: { name: string }) => label.name),
+      paths: [],
+    });
+  };
+  const first = await metadata();
+  const paths: string[] = [];
+  for (let page = 1; page <= Math.ceil(first.changedFiles / 100); page++) {
+    const files = await read(`${endpoint}/files?per_page=100&page=${page}`);
+    if (!Array.isArray(files))
+      throw new Error("GitHub returned an invalid file list.");
+    paths.push(...files.map((file: { filename: string }) => file.filename));
+  }
+  stable(first, await metadata());
+  return assertComplete({ ...first, paths });
+}
+export function createPullReader(gh?: GitHubCli): ReadPull {
+  return async (input, pr, signal) => {
+    const repository = repositoryName(input);
+    if (!Number.isSafeInteger(pr) || pr < 1)
+      throw new Error("Invalid PR number.");
+    signal.throwIfAborted();
+    if (gh) {
+      try {
+        return await graphql(gh, repository, pr, signal);
+      } catch (error) {
+        if (!(error instanceof GhUnavailable) || signal.aborted) throw error;
+      }
+    }
+    return publicRead(repository, pr, signal);
+  };
+}
diff --git a/src/bundled/review-configuration/review-configuration.css b/src/bundled/review-configuration/review-configuration.css
index 1bc0f186e6..0c95b66e77 100644
--- a/src/bundled/review-configuration/review-configuration.css
+++ b/src/bundled/review-configuration/review-configuration.css
@@ -52,3 +52,11 @@
   white-space: pre-wrap;
   overflow-wrap: anywhere;
 }
+
+.review-config-pr-summary {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: baseline;
+  gap: var(--space-2) var(--space-4);
+  overflow-wrap: anywhere;
+}
diff --git a/src/bundled/review-configuration/routing.test.ts b/src/bundled/review-configuration/routing.test.ts
new file mode 100644
index 0000000000..7fe2783dd2
--- /dev/null
+++ b/src/bundled/review-configuration/routing.test.ts
@@ -0,0 +1,98 @@
+import { expect, it } from "vitest";
+import {
+  laneMatches,
+  pathMatches,
+  validateRouting,
+  type LaneRule,
+  type PullFacts,
+} from "./routing";
+const facts: PullFacts = {
+  repository: "example-org/project",
+  pr: 1,
+  title: "Fix authentication",
+  labels: ["Security", "backend"],
+  changedFiles: 2,
+  paths: ["src/auth.ts", "src/ui/form.tsx"],
+  head: "a".repeat(40),
+  base: "b".repeat(40),
+};
+const rule = (
+  field: LaneRule["field"],
+  operator: LaneRule["operator"],
+  value: string,
+): LaneRule => ({ id: crypto.randomUUID(), field, operator, value });
+it("routes title, exact labels, counts and glob paths with all/any semantics", () => {
+  const rules = [
+    rule("title", "contains", "AUTH"),
+    rule("label", "has", "security"),
+    rule("files", "at-least", "2"),
+    rule("files", "at-most", "2"),
+    rule("path", "matches", "src/**/*.tsx"),
+  ];
+  expect(laneMatches(validateRouting({ mode: "all", rules }), facts)).toBe(
+    true,
+  );
+  const missing = rule("label", "has", "sec");
+  expect(laneMatches({ mode: "all", rules: [...rules, missing] }, facts)).toBe(
+    false,
+  );
+  expect(laneMatches({ mode: "any", rules: [...rules, missing] }, facts)).toBe(
+    true,
+  );
+  expect(laneMatches(undefined, facts)).toBe(true);
+  expect(laneMatches({ mode: "any", rules: [] }, facts)).toBe(true);
+});
+it("negative path means no changed file matches, not at least one differs", () => {
+  expect(
+    laneMatches(
+      { mode: "all", rules: [rule("path", "not-matches", "src/*.ts")] },
+      facts,
+    ),
+  ).toBe(false);
+  expect(
+    laneMatches(
+      {
+        mode: "all",
+        rules: [
+          rule("path", "not-matches", "docs/**"),
+          rule("title", "not-contains", "feature"),
+          rule("label", "not-has", "UI"),
+        ],
+      },
+      facts,
+    ),
+  ).toBe(true);
+});
+it.each([
+  ["**/*.tsx", "form.tsx", true],
+  ["src/**", "src/auth.ts", true],
+  ["src/*.tsx", "src/ui/form.tsx", false],
+  ["src/**/*.tsx", "src/form.tsx", true],
+  ["src/?.ts", "src/a.ts", true],
+  ["src/?.ts", "src/ab.ts", false],
+  ["SRC/**", "src/a.ts", false],
+  ["src/[x].ts", "src/[x].ts", true],
+])("matches %s against %s", (pattern, path, expected) =>
+  expect(pathMatches(pattern, path)).toBe(expected),
+);
+it("rejects malformed and unsupported persisted rules", () => {
+  for (const raw of [
+    null,
+    { mode: "no", rules: [] },
+    { mode: "all", rules: Array(13).fill(rule("title", "contains", "a")) },
+    ...[
+      rule("files", "at-least", "-1"),
+      rule("files", "at-most", "1.5"),
+      rule("path", "matches", "../**"),
+      rule("path", "matches", "/src/**"),
+      rule("path", "matches", "s**"),
+      rule("path", "matches", "[abc]"),
+      rule("label", "contains", "foo"),
+    ].map((item) => ({ mode: "all", rules: [item] })),
+  ])
+    expect(() => validateRouting(raw)).toThrow();
+  const repeated = rule("title", "contains", "x");
+  expect(() =>
+    validateRouting({ mode: "all", rules: [repeated, repeated] }),
+  ).toThrow();
+});
diff --git a/src/bundled/review-configuration/routing.ts b/src/bundled/review-configuration/routing.ts
new file mode 100644
index 0000000000..a1e72c96cf
--- /dev/null
+++ b/src/bundled/review-configuration/routing.ts
@@ -0,0 +1,176 @@
+export type LaneRule = Readonly<{
+  id: string;
+  field: "title" | "label" | "files" | "path";
+  operator:
+    | "contains"
+    | "not-contains"
+    | "has"
+    | "not-has"
+    | "at-least"
+    | "at-most"
+    | "matches"
+    | "not-matches";
+  value: string;
+}>;
+export type LaneRouting = Readonly<{
+  mode: "all" | "any";
+  rules: readonly LaneRule[];
+}>;
+export type PullFacts = Readonly<{
+  repository: string;
+  pr: number;
+  title: string;
+  labels: readonly string[];
+  changedFiles: number;
+  paths: readonly string[];
+  head: string;
+  base: string;
+}>;
+export const ruleFields = [
+  { value: "title", label: "Title" },
+  { value: "label", label: "Label" },
+  { value: "files", label: "Total changed files" },
+  { value: "path", label: "Changed file path" },
+] as const;
+export const ruleOperators = {
+  title: [
+    { value: "contains", label: "contains" },
+    { value: "not-contains", label: "does not contain" },
+  ],
+  label: [
+    { value: "has", label: "includes" },
+    { value: "not-has", label: "does not include" },
+  ],
+  files: [
+    { value: "at-least", label: "is at least" },
+    { value: "at-most", label: "is at most" },
+  ],
+  path: [
+    { value: "matches", label: "matches pattern" },
+    { value: "not-matches", label: "does not match pattern" },
+  ],
+} as const;
+
+export function validateRouting(raw: unknown): LaneRouting {
+  if (!raw || typeof raw !== "object")
+    throw new Error("Invalid lane routing rules.");
+  const value = raw as LaneRouting;
+  if (
+    !["all", "any"].includes(value.mode) ||
+    !Array.isArray(value.rules) ||
+    value.rules.length > 12
+  )
+    throw new Error("Choose all or any, with up to 12 routing rules per lane.");
+  const ids = new Set<string>();
+  const rules = value.rules.map((rule: LaneRule) => {
+    if (
+      !rule ||
+      typeof rule.id !== "string" ||
+      !/^[a-z0-9-]{1,64}$/i.test(rule.id) ||
+      ids.has(rule.id) ||
+      !Object.hasOwn(ruleOperators, rule.field) ||
+      !ruleOperators[rule.field].some((item) => item.value === rule.operator) ||
+      typeof rule.value !== "string" ||
+      !rule.value.trim() ||
+      rule.value.length > 200
+    )
+      throw new Error(
+        "Each routing rule needs a valid field, comparison, and value (up to 200 characters).",
+      );
+    ids.add(rule.id);
+    const text = rule.value.trim();
+    if (
+      rule.field === "files" &&
+      (!/^\d+$/.test(text) || !Number.isSafeInteger(Number(text)))
+    )
+      throw new Error(
+        "Changed-file counts must be whole numbers of zero or more.",
+      );
+    if (
+      rule.field === "path" &&
+      (text.startsWith("/") ||
+        /[\\[\]{}]/.test(text) ||
+        text
+          .split("/")
+          .some(
+            (part) =>
+              !part ||
+              part === "." ||
+              part === ".." ||
+              (part.includes("**") && part !== "**"),
+          ))
+    )
+      throw new Error(
+        "Use a repository-relative path pattern with *, ?, or ** as a whole directory segment.",
+      );
+    return {
+      id: rule.id,
+      field: rule.field,
+      operator: rule.operator,
+      value: text,
+    };
+  });
+  return { mode: value.mode, rules };
+}
+
+// Remember only the latest wildcard; avoid allocating a matrix for each filename.
+function segmentMatches(pattern: string, text: string) {
+  let p = 0;
+  let t = 0;
+  let star = -1;
+  let retry = 0;
+  while (t < text.length) {
+    if (pattern[p] === "?" || pattern[p] === text[t]) {
+      p++;
+      t++;
+    } else if (pattern[p] === "*") {
+      star = p++;
+      retry = t;
+    } else if (star >= 0) {
+      p = star + 1;
+      t = ++retry;
+    } else return false;
+  }
+  while (pattern[p] === "*") p++;
+  return p === pattern.length;
+}
+export function pathMatches(pattern: string, path: string) {
+  const segments = path.split("/");
+  let row = Array<boolean>(segments.length + 1).fill(false);
+  row[0] = true;
+  for (const part of pattern.split("/")) {
+    const next = Array<boolean>(segments.length + 1).fill(false);
+    next[0] = part === "**" && !!row[0];
+    for (let i = 1; i <= segments.length; i++)
+      next[i] =
+        part === "**"
+          ? !!row[i] || !!next[i - 1]
+          : !!row[i - 1] && segmentMatches(part, segments[i - 1] ?? "");
+    row = next;
+  }
+  return !!row[segments.length];
+}
+export function laneMatches(
+  routing: LaneRouting | undefined,
+  facts: PullFacts,
+): boolean {
+  if (!routing?.rules.length) return true;
+  const matches = (rule: LaneRule) => {
+    const positive =
+      rule.field === "title"
+        ? facts.title.toLowerCase().includes(rule.value.toLowerCase())
+        : rule.field === "label"
+          ? facts.labels.some(
+              (label) => label.toLowerCase() === rule.value.toLowerCase(),
+            )
+          : rule.field === "files"
+            ? rule.operator === "at-least"
+              ? facts.changedFiles >= Number(rule.value)
+              : facts.changedFiles <= Number(rule.value)
+            : facts.paths.some((path) => pathMatches(rule.value, path));
+    return rule.operator.startsWith("not-") ? !positive : positive;
+  };
+  return routing.mode === "all"
+    ? routing.rules.every(matches)
+    : routing.rules.some(matches);
+}
diff --git a/src/bundled/review-configuration/submissions.test.ts b/src/bundled/review-configuration/submissions.test.ts
index 5813ec798a..d2dd34e0d8 100644
--- a/src/bundled/review-configuration/submissions.test.ts
+++ b/src/bundled/review-configuration/submissions.test.ts
@@ -205,34 +205,34 @@ it("validates canonical PR input and refuses other repositories or non-PR URLs",
     expect(() => pullRequest(input, "example-org/project")).toThrow();
 });
 
-it("saves the instruction snapshot and creates one overview plus distinct lane threads", async () => {
+it("saves the instruction snapshot and creates only distinct lane threads, without an overview", async () => {
   const f = await fixture();
   const record = await f.run();
   expect(record.value.threads.every((thread) => thread.delivered)).toBe(true);
-  expect(f.messages.size).toBe(3);
+  expect(f.messages.size).toBe(2);
   const messages = [...f.messages.values()];
-  expect(messages[0]?.tags.some((tag) => tag[0] === "p")).toBe(false);
-  for (const [index, message] of messages.slice(1).entries()) {
+  expect(record.value.version).toBe(2);
+  for (const [index, message] of messages.entries()) {
     expect(message.tags).toContainEqual(["p", f.agent.pubkey]);
     expect(message.tags.some((tag) => tag[0] === "e")).toBe(false);
     expect(message.content).toContain(
       f.config.config.lanes[index]?.instructions,
     );
-    expect(message.content).toContain(record.value.threads[0]?.id);
+    expect(message.content).not.toContain("Overview:");
   }
   expect(
     (await loadSubmissions(f.session, channel, new AbortController().signal))
       .rows[0],
   ).toEqual(record);
   await f.run();
-  expect(f.publish).toHaveBeenCalledTimes(3);
+  expect(f.publish).toHaveBeenCalledTimes(2);
 });
 
 it("serializes simultaneous submissions of the same PR", async () => {
   const f = await fixture();
   const [first, second] = await Promise.all([f.run(), f.run()]);
   expect(first.value.threads).toEqual(second.value.threads);
-  expect(f.messages.size).toBe(3);
+  expect(f.messages.size).toBe(2);
 });
 
 it("retries the same signed event after ambiguous publication without duplicating threads", async () => {
@@ -245,7 +245,7 @@ it("retries the same signed event after ambiguous publication without duplicatin
   const firstId = f.publish.mock.calls[0]?.[0].id;
   await f.run("123", undefined, true);
   expect(f.publish.mock.calls[1]?.[0].id).toBe(firstId);
-  expect(f.messages.size).toBe(3);
+  expect(f.messages.size).toBe(2);
 });
 
 it("recovers a send whose artifact update failed before its ID was saved", async () => {
@@ -258,8 +258,8 @@ it("recovers a send whose artifact update failed before its ID was saved", async
     .mockRejectedValueOnce(new Error("save interrupted"));
   await expect(f.run()).rejects.toThrow("save interrupted");
   await f.run("123", undefined, true);
-  expect(f.messages.size).toBe(3);
-  expect(f.publish).toHaveBeenCalledTimes(3);
+  expect(f.messages.size).toBe(2);
+  expect(f.publish).toHaveBeenCalledTimes(2);
 });
 
 it("does not take over incomplete delivery after browser recovery storage is lost", async () => {
@@ -295,7 +295,7 @@ it("stops on cancellation and resumes only the saved message IDs", async () => {
   const firstId = f.publish.mock.calls[0]?.[0].id;
   await f.run("123", undefined, true);
   expect(f.messages.has(firstId ?? "")).toBe(true);
-  expect(f.messages.size).toBe(3);
+  expect(f.messages.size).toBe(2);
 });
 
 it("opens an existing incomplete record without sending a changed preview", async () => {
@@ -359,5 +359,117 @@ it("can resume after a proven rejection before enqueue", async () => {
   ).rows[0];
   expect(saved?.value.threads[0]).toEqual({});
   await f.run("123", undefined, true);
-  expect(f.messages.size).toBe(3);
+  expect(f.messages.size).toBe(2);
+});
+
+it("routes to every matching lane and refuses to send when no lane matches", async () => {
+  const f = await fixture();
+  const facts = {
+    repository: "example-org/project",
+    pr: 124,
+    title: "UI fix",
+    labels: [],
+    changedFiles: 1,
+    paths: ["ui/form.tsx"],
+    head: "a".repeat(40),
+    base: "b".repeat(40),
+  };
+  const saved: SavedReviewConfig = {
+    ...f.config,
+    config: {
+      ...f.config.config,
+      lanes: f.config.config.lanes.map((lane) => ({
+        ...lane,
+        routing: {
+          mode: "all",
+          rules: [
+            {
+              id: lane.id,
+              field: "path",
+              operator: "matches",
+              value: `${lane.id}/**`,
+            },
+          ],
+        },
+      })),
+    },
+  };
+  await expect(
+    submitReview(
+      f.session,
+      channel,
+      saved,
+      "124",
+      [f.agent.pubkey, f.agent.pubkey],
+      new AbortController().signal,
+      () => {},
+    ),
+  ).rejects.toThrow("Load PR details");
+  expect(f.heads.size).toBe(0);
+  const record = await submitReview(
+    f.session,
+    channel,
+    saved,
+    "124",
+    [f.agent.pubkey, f.agent.pubkey],
+    new AbortController().signal,
+    () => {},
+    false,
+    facts,
+  );
+  expect(record.value.config.lanes.map((lane) => lane.name)).toEqual(["UI"]);
+  expect(f.messages.size).toBe(1);
+  expect([...f.messages.values()][0]?.content).toContain(
+    "Check keyboard access.",
+  );
+  await expect(
+    submitReview(
+      f.session,
+      channel,
+      saved,
+      "125",
+      [f.agent.pubkey, f.agent.pubkey],
+      new AbortController().signal,
+      () => {},
+      false,
+      { ...facts, pr: 125, paths: ["docs/a.md"] },
+    ),
+  ).rejects.toThrow("No lanes match");
+  expect(f.messages.size).toBe(1);
+});
+
+it("retains old overview and lane IDs when reloading and resuming a version-one record", async () => {
+  const f = await fixture();
+  const record = await f.run();
+  const head = f.heads.get(record.artifactId);
+  if (!head) throw new Error("Missing fixture head");
+  const overview = signed(f.owner, {
+    kind: 9,
+    content: "Earlier overview",
+    tags: [["h", channel]],
+  });
+  f.messages.set(overview.id, overview);
+  const value = {
+    ...record.value,
+    version: 1,
+    threads: [
+      { id: overview.id, delivered: true },
+      ...record.value.threads.map((thread) => ({ id: thread.id })),
+    ],
+  };
+  f.heads.set(
+    record.artifactId,
+    signed(f.owner, {
+      kind: head.kind,
+      content: JSON.stringify(value),
+      tags: head.tags,
+    }),
+  );
+  const resumed = await f.run("123", undefined, true);
+  expect(resumed.value.version).toBe(1);
+  expect(resumed.value.threads.map((thread) => thread.id)).toEqual(
+    value.threads.map((thread) => thread.id),
+  );
+  expect(resumed.value.threads.every((thread) => thread.delivered)).toBe(true);
+  expect(f.publish).toHaveBeenCalledTimes(2);
 });
diff --git a/src/bundled/review-configuration/submissions.ts b/src/bundled/review-configuration/submissions.ts
index a6cb7d345a..eca124c963 100644
--- a/src/bundled/review-configuration/submissions.ts
+++ b/src/bundled/review-configuration/submissions.ts
@@ -1,3 +1,4 @@
+import { laneMatches, type PullFacts } from "./routing";
 import { npubEncode } from "nostr-tools/nip19";
 import { profileMentionLink } from "../../features/messages/message-edit";
 import {
@@ -20,7 +21,7 @@ const HEX = /^[0-9a-f]{64}$/;
 const UUID = /^[0-9a-f-]{36}$/;
 type Thread = { id?: string; started?: true; delivered?: true };
 export type Submission = {
-  version: 1;
+  version: 1 | 2;
   pr: number;
   config: ReviewConfig;
   configRevision: string;
@@ -73,7 +74,7 @@ async function decode(
   const value = JSON.parse(event.content) as Submission;
   const config = validateConfig(value.config);
   if (
-    value.version !== 1 ||
+    (value.version !== 1 && value.version !== 2) ||
     !Number.isSafeInteger(value.pr) ||
     value.pr < 1 ||
     value.submitter !== event.pubkey ||
@@ -81,7 +82,8 @@ async function decode(
     !UUID.test(value.device) ||
     config.lanes.some((lane) => lane.reviewers.length !== 1) ||
     !Array.isArray(value.threads) ||
-    value.threads.length !== config.lanes.length + 1 ||
+    value.threads.length !==
+      config.lanes.length + (value.version === 1 ? 1 : 0) ||
     value.threads.some(
       (thread) =>
         !thread ||
@@ -182,13 +184,17 @@ function deviceId(scope: string) {
   return value;
 }
 
+export function submissionLane(value: Submission, index: number) {
+  return value.config.lanes[index - (value.version === 1 ? 1 : 0)];
+}
+
 export function threadMessage(
   value: Submission,
   channel: string,
   index: number,
   reviewerName = "Reviewer",
 ) {
-  const lane = value.config.lanes[index - 1];
+  const lane = submissionLane(value, index);
   const title = `${value.config.repository}#${value.pr}${lane ? ` · ${lane.name}` : " · Review"}`;
   return {
     kind: 9,
@@ -198,7 +204,7 @@ export function threadMessage(
       ...(lane ? [["p", lane.reviewers[0] ?? ""]] : []),
     ],
     content: lane
-      ? `Review request: ${prUrl(value)}\n\nReviewer: ${profileMentionLink(`@${reviewerName}`, `nostr:${npubEncode(lane.reviewers[0] ?? "")}`)}\nLane: ${lane.name}\n\n${lane.instructions}\n\nReply in this thread with the commit you reviewed, findings, and any blockers. Verify the current PR and repository before reviewing. This submission does not pin a commit or post a GitHub review.\n\nOverview: ${threadUrl(channel, value.threads[0]?.id ?? "")}`
+      ? `Review request: ${prUrl(value)}\n\nReviewer: ${profileMentionLink(`@${reviewerName}`, `nostr:${npubEncode(lane.reviewers[0] ?? "")}`)}\nLane: ${lane.name}\n\n${lane.instructions}\n\nReply in this thread with the commit you reviewed, findings, and any blockers. Verify the current PR and repository before reviewing. This submission does not pin a commit or post a GitHub review.${value.version === 1 ? `\n\nOverview: ${threadUrl(channel, value.threads[0]?.id ?? "")}` : ""}`
       : `Review request: ${prUrl(value)}\n\nLanes: ${value.config.lanes.map((item) => item.name).join(", ")}\n\nLane threads and delivery status are listed in Review Configuration. A delivered request does not mean the reviewer has started. Automatic reminders are off.`,
   };
 }
@@ -297,6 +303,7 @@ export async function submitReview(
   signal: AbortSignal,
   onProgress: (value: SavedSubmission) => void,
   resume = false,
+  facts?: PullFacts,
 ) {
   const outbox = session.outbox;
   const read = session.snapshotRead;
@@ -330,9 +337,26 @@ export async function submitReview(
       const head = events[0];
       if (head) record = await decode(head, channel);
       else {
+        if (
+          facts &&
+          (facts.repository !== saved.config.repository || facts.pr !== pr)
+        )
+          throw new Error("The loaded PR does not match this submission.");
+        if (
+          !facts &&
+          saved.config.lanes.some((lane) => lane.routing?.rules.length)
+        )
+          throw new Error("Load PR details before routing this submission.");
+        const matched = saved.config.lanes.flatMap((lane, i) =>
+          !facts || laneMatches(lane.routing, facts) ? [{ lane, i }] : [],
+        );
+        if (!matched.length)
+          throw new Error(
+            "No lanes match this PR. No review requests were sent.",
+          );
         const config = validateConfig({
           ...saved.config,
-          lanes: saved.config.lanes.map((lane, i) => {
+          lanes: matched.map(({ lane, i }) => {
             const reviewer = reviewers[i];
             if (!reviewer || !lane.reviewers.includes(reviewer))
               throw new Error(`Choose a configured reviewer for ${lane.name}.`);
@@ -340,13 +364,13 @@ export async function submitReview(
           }),
         });
         const value: Submission = {
-          version: 1,
+          version: 2,
           pr,
           config,
           configRevision: saved.revision,
           submitter: viewer,
           device,
-          threads: Array.from({ length: config.lanes.length + 1 }, () => ({})),
+          threads: Array.from({ length: config.lanes.length }, () => ({})),
         };
         await eligible(session, value, signal);
         record = await write(session, channel, value, undefined, signal);
@@ -444,7 +468,7 @@ export async function submitReview(
                     .selectable.find(
                       (choice) =>
                         choice.pubkey ===
-                        record.value.config.lanes[index - 1]?.reviewers[0],
+                        submissionLane(record.value, index)?.reviewers[0],
                     )?.name,
                 ),
                 { key, value: artifactId },

From fcbb2d1875f5f834982a9593e6d719b86bf96de5 Mon Sep 17 00:00:00 2001
From: Ravneet Arora <rarora@squareup.com>
Date: Thu, 12 Nov 2026 12:37:28 -0500
Subject: [PATCH 05/17] Separate repository settings and route pasted PR URLs

Co-authored-by: maincourse <37ce551b493d4a998caf030929c47bce0b6a0e43f1178b3a63c4151d7c16b76e@buzz.block.builderlab.xyz>
Signed-off-by: Ravneet Arora <rarora@squareup.com>
---
 docs/buzz-help.md                             |   7 +-
 .../review-configuration/LaneRules.tsx        |   5 +-
 src/bundled/review-configuration/README.md    |  17 +-
 .../ReviewConfigurationPage.test.tsx          | 212 +++++-
 .../ReviewConfigurationPage.tsx               | 696 ++++++++++++------
 .../ReviewSubmissions.tsx                     |  98 +--
 .../review-configuration.css                  |  38 +-
 .../review-configuration/submissions.test.ts  |  21 +-
 .../review-configuration/submissions.ts       |  13 +
 9 files changed, 776 insertions(+), 331 deletions(-)

diff --git a/docs/buzz-help.md b/docs/buzz-help.md
index 6fcb6b3a96..4d8abf1f31 100644
--- a/docs/buzz-help.md
+++ b/docs/buzz-help.md
@@ -1161,7 +1161,12 @@ confirmation. **Delete team** asks first; it doesn't delete the team's agents.
   reads the latest saved versions. Settings live on the community relay and are
   visible to channel readers; members who can post can edit them. A conflicting
   edit preserves your draft: copy your changes before cancelling and reloading.
-  **Submit PR** accepts a PR number or URL for a saved repository and one reviewer
+  **Submit PR** on the repository list finds the configured repository from a full
+  GitHub PR URL, then opens its matching-lane preview flow.
+  Open one repository at a time. **Configuration** contains expandable lane settings;
+  **Pull requests** contains **Submit PR** and that repository’s **Existing PRs**.
+  Save or cancel an open draft before switching views.
+  **Submit PR** accepts a PR number or URL for that repository and one reviewer
   per matching lane. Optional all/any rules match title text, exact labels, changed-file
   counts, and path patterns such as `src/**/*.tsx`. No rules matches every PR.
   **Load PR details** previews matching lanes; zero matches sends nothing.
diff --git a/src/bundled/review-configuration/LaneRules.tsx b/src/bundled/review-configuration/LaneRules.tsx
index 8a775696c5..4755824e36 100644
--- a/src/bundled/review-configuration/LaneRules.tsx
+++ b/src/bundled/review-configuration/LaneRules.tsx
@@ -48,7 +48,7 @@ export function LaneRules({
         }
       />
       {routing.rules.map((rule, index) => (
-        <div className="review-config-form" key={rule.id}>
+        <div className="review-config-rule" key={rule.id}>
           <Select
             label={`Lane ${lane} rule ${index + 1} field`}
             variant="field"
@@ -104,6 +104,7 @@ export function LaneRules({
           <div>
             <Button
               disabled={disabled}
+              aria-label={`Remove rule ${index + 1} from lane ${lane}`}
               onClick={() =>
                 onChange({
                   ...routing,
@@ -111,7 +112,7 @@ export function LaneRules({
                 })
               }
             >
-              Remove rule {index + 1} from lane {lane}
+              Remove
             </Button>
           </div>
         </div>
diff --git a/src/bundled/review-configuration/README.md b/src/bundled/review-configuration/README.md
index 99332e6b6b..3879953496 100644
--- a/src/bundled/review-configuration/README.md
+++ b/src/bundled/review-configuration/README.md
@@ -3,11 +3,20 @@
 An optional bundled plugin with a separate sidebar page for repository review
 settings. Enable **Review Configuration** in Settings → Plugins → Manage plugins.
 Choose a channel, register a GitHub repository, add named lanes, reviewer agents, and instructions,
-and save. The repository table supports editing and an explicit reload. The page
+and save. Open a repository row to work with one repository at a time. Its **Configuration**
+section contains lane settings; **Pull requests** contains Submit PR and Existing PRs.
+Lane editors and routing rules expand on demand. Cancel or save a draft before
+switching sections or repositories. These are local page sections: reload returns
+to the repository list; they do not create separate shell tabs or history visits. The page
 remembers your channel per identity/community and selects it automatically when
 only one eligible channel is available.
 
-Use **Submit PR** to select a saved repository, enter a PR number or URL, and
+From the repository list, **Submit PR** accepts a full GitHub PR URL and finds
+its configured repository in the selected channel. Unknown repositories must be
+registered first. The matched repository opens in Pull requests with the URL
+filled in; Load PR details previews its matching lanes before sending.
+
+In a repository’s **Pull requests** section, use **Submit PR**, enter a PR number or URL, and
 load PR details to preview matching lanes, then choose one configured reviewer
 per matching lane. **Start review threads** saves the instruction snapshot,
 creates one thread per matching lane with no overview, and mentions
@@ -19,7 +28,7 @@ or reviewing. No model process or reminder timer is started by this plugin.
 
 Enable this plugin in **Settings → Plugins → Manage plugins**, then open its
 sidebar entry. Choose a channel and register a repository. For each lane, select
-reviewer agents and enter instructions, then save. Use the table to edit settings.
+reviewer agents and enter instructions, then save. Open its Configuration section to edit settings.
 These selections do not start reviews or grant agents access to the channel.
 
 ---
@@ -113,7 +122,7 @@ A missing outbox message with a known ID is checked against the relay before
 recording delivery.
 No background retries, polling, or model runtime are added.
 
-Opening a channel adds one bounded submissions read (latest 100, with truncation
+Opening Pull requests adds one bounded submissions read (latest 100, with truncation
 notice). Submission explicitly reads the current record and reviewer profiles,
 refreshes agent choices, and uses the outbox's per-message membership preflight.
 Reconnect introduces no new plugin reads.
diff --git a/src/bundled/review-configuration/ReviewConfigurationPage.test.tsx b/src/bundled/review-configuration/ReviewConfigurationPage.test.tsx
index cca08d3272..ec9ca36904 100644
--- a/src/bundled/review-configuration/ReviewConfigurationPage.test.tsx
+++ b/src/bundled/review-configuration/ReviewConfigurationPage.test.tsx
@@ -131,6 +131,8 @@ async function openDraft() {
     screen.getByRole("textbox", { name: "GitHub repository" }),
     "example-org/project",
   );
+  if (!screen.queryByRole("textbox", { name: "Lane 1 instructions" }))
+    await user.click(screen.getByRole("button", { name: /^General/ }));
   await user.type(
     screen.getByRole("textbox", { name: "Lane 1 instructions" }),
     "Check authorization and keyboard navigation.",
@@ -143,14 +145,16 @@ it("registers, reloads and edits a repository through the real form and artifact
   render(<ReviewConfigurationCommunity session={test.session} />);
   const user = await openDraft();
   await user.click(screen.getByRole("button", { name: "Save settings" }));
-  await screen.findByText(
-    "Saved example-org/project. Use Submit PR to start review threads.",
-  );
+  await screen.findByText("Saved example-org/project.");
   await user.click(screen.getByRole("button", { name: "Reload" }));
   await screen.findByRole("button", { name: "Edit example-org/project" });
   await user.click(
     screen.getByRole("button", { name: "Edit example-org/project" }),
   );
+  if (!screen.queryByRole("textbox", { name: "Lane 1 instructions" }))
+    await userEvent
+      .setup()
+      .click(screen.getByRole("button", { name: /^General/ }));
   expect(
     (
       screen.getByRole("textbox", {
@@ -161,14 +165,14 @@ it("registers, reloads and edits a repository through the real form and artifact
   await user.clear(
     screen.getByRole("textbox", { name: "Lane 1 instructions" }),
   );
+  if (!screen.queryByRole("textbox", { name: "Lane 1 instructions" }))
+    await user.click(screen.getByRole("button", { name: /^General/ }));
   await user.type(
     screen.getByRole("textbox", { name: "Lane 1 instructions" }),
     "Check database migrations.",
   );
   await user.click(screen.getByRole("button", { name: "Save settings" }));
-  await screen.findByText(
-    "Saved example-org/project. Use Submit PR to start review threads.",
-  );
+  await screen.findByText("Saved example-org/project.");
   expect(test.publish).toHaveBeenCalledTimes(2);
   expect(test.publish.mock.calls[1]?.[0].tags).toContainEqual([
     "prev",
@@ -197,6 +201,10 @@ it("keeps the draft on rejection, prevents duplicate submissions, and recovers",
   expect((await screen.findByRole("alert")).textContent).toContain(
     "Your draft is still here",
   );
+  if (!screen.queryByRole("textbox", { name: "Lane 1 instructions" }))
+    await userEvent
+      .setup()
+      .click(screen.getByRole("button", { name: /^General/ }));
   expect(
     (
       screen.getByRole("textbox", {
@@ -205,9 +213,7 @@ it("keeps the draft on rejection, prevents duplicate submissions, and recovers",
     ).value,
   ).toContain("keyboard navigation");
   await user.click(screen.getByRole("button", { name: "Save settings" }));
-  await screen.findByText(
-    "Saved example-org/project. Use Submit PR to start review threads.",
-  );
+  await screen.findByText("Saved example-org/project.");
 });
 
 it("preserves the draft while channel authorization reconfirms, but gates Save", async () => {
@@ -219,6 +225,10 @@ it("preserves the draft while channel authorization reconfirms, but gates Save",
     (screen.getByRole("button", { name: "Save settings" }) as HTMLButtonElement)
       .disabled,
   ).toBe(true);
+  if (!screen.queryByRole("textbox", { name: "Lane 1 instructions" }))
+    await userEvent
+      .setup()
+      .click(screen.getByRole("button", { name: /^General/ }));
   expect(
     (
       screen.getByRole("textbox", {
@@ -231,6 +241,10 @@ it("preserves the draft while channel authorization reconfirms, but gates Save",
     (screen.getByRole("button", { name: "Save settings" }) as HTMLButtonElement)
       .disabled,
   ).toBe(false);
+  if (!screen.queryByRole("textbox", { name: "Lane 1 instructions" }))
+    await userEvent
+      .setup()
+      .click(screen.getByRole("button", { name: /^General/ }));
   expect(
     (
       screen.getByRole("textbox", {
@@ -287,14 +301,15 @@ it("counts unreadable records toward the limit when a new repository is saved",
     screen.getByRole("textbox", { name: "GitHub repository" }),
     "example-org/project",
   );
+  if (!screen.queryByRole("textbox", { name: "Lane 1 instructions" }))
+    await user.click(screen.getByRole("button", { name: /^General/ }));
   await user.type(
     screen.getByRole("textbox", { name: "Lane 1 instructions" }),
     "Check tests.",
   );
   await user.click(screen.getByRole("button", { name: "Save settings" }));
-  await screen.findByText(
-    "Saved example-org/project. Use Submit PR to start review threads.",
-  );
+  await screen.findByText("Saved example-org/project.");
+  await user.click(screen.getByRole("button", { name: "All repositories" }));
   expect(
     (
       screen.getByRole("button", {
@@ -317,9 +332,7 @@ it("saves multiple lane reviewers, reloads their identities, and preserves unava
     await screen.findByRole("option", { name: "UI reviewer (bbbbbbbb)" }),
   );
   await user.click(screen.getByRole("button", { name: "Save settings" }));
-  await screen.findByText(
-    "Saved example-org/project. Use Submit PR to start review threads.",
-  );
+  await screen.findByText("Saved example-org/project.");
   const content = test.publish.mock.calls[0]?.[0].content;
   expect(JSON.parse(content ?? "{}").lanes[0].reviewers).toEqual([
     "a".repeat(64),
@@ -329,6 +342,7 @@ it("saves multiple lane reviewers, reloads their identities, and preserves unava
   await user.click(
     await screen.findByRole("button", { name: "Edit example-org/project" }),
   );
+  await user.click(screen.getByRole("button", { name: /^General/ }));
   await screen.findByRole("button", {
     name: "Remove Backend reviewer from lane 1",
   });
@@ -338,9 +352,7 @@ it("saves multiple lane reviewers, reloads their identities, and preserves unava
     screen.getByRole("button", { name: "Remove Backend reviewer from lane 1" }),
   );
   await user.click(screen.getByRole("button", { name: "Save settings" }));
-  await screen.findByText(
-    "Saved example-org/project. Use Submit PR to start review threads.",
-  );
+  await screen.findByText("Saved example-org/project.");
   expect(
     JSON.parse(test.publish.mock.calls[1]?.[0].content ?? "{}").lanes[0]
       .reviewers,
@@ -361,9 +373,7 @@ it("refreshes failed agent and archive reads without discarding the draft", asyn
     await screen.findByRole("option", { name: "Backend reviewer (aaaaaaaa)" }),
   );
   await user.click(screen.getByRole("button", { name: "Save settings" }));
-  await screen.findByText(
-    "Saved example-org/project. Use Submit PR to start review threads.",
-  );
+  await screen.findByText("Saved example-org/project.");
   expect(
     JSON.parse(test.publish.mock.calls[0]?.[0].content ?? "null").lanes[0]
       .reviewers,
@@ -421,6 +431,7 @@ it("saves path rules through field changes and preserves them after reload", asy
   const test = fixture();
   render(<ReviewConfigurationCommunity session={test.session} />);
   const user = await openDraft();
+  await user.click(screen.getByRole("button", { name: /^Routing rules/ }));
   await user.click(screen.getByRole("button", { name: "Add rule to lane 1" }));
   await user.click(
     screen.getByRole("combobox", { name: "Lane 1 rule 1 field" }),
@@ -433,9 +444,7 @@ it("saves path rules through field changes and preserves them after reload", asy
     "src/**/*.tsx",
   );
   await user.click(screen.getByRole("button", { name: "Save settings" }));
-  await screen.findByText(
-    "Saved example-org/project. Use Submit PR to start review threads.",
-  );
+  await screen.findByText("Saved example-org/project.");
   const saved = JSON.parse(test.publish.mock.calls[0]?.[0].content ?? "{}")
     .lanes[0].routing;
   expect(saved.rules[0]).toMatchObject({
@@ -448,6 +457,8 @@ it("saves path rules through field changes and preserves them after reload", asy
   await user.click(
     await screen.findByRole("button", { name: "Edit example-org/project" }),
   );
+  await user.click(screen.getByRole("button", { name: /^General/ }));
+  await user.click(screen.getByRole("button", { name: /^Routing rules/ }));
   expect(
     (
       screen.getByRole("textbox", {
@@ -459,9 +470,7 @@ it("saves path rules through field changes and preserves them after reload", asy
     screen.getByRole("button", { name: "Remove rule 1 from lane 1" }),
   );
   await user.click(screen.getByRole("button", { name: "Save settings" }));
-  await screen.findByText(
-    "Saved example-org/project. Use Submit PR to start review threads.",
-  );
+  await screen.findByText("Saved example-org/project.");
   expect(
     JSON.parse(test.publish.mock.calls[1]?.[0].content ?? "{}").lanes[0].routing
       .rules,
@@ -498,3 +507,152 @@ it("preserves the remembered channel until pending metadata finishes", async ()
     second,
   );
 });
+
+it("separates a repository's PR activity and guards drafts before switching views", async () => {
+  const test = fixture();
+  render(<ReviewConfigurationCommunity session={test.session} />);
+  const user = await openDraft();
+  await user.click(screen.getByRole("button", { name: "Save settings" }));
+  await screen.findByText("Saved example-org/project.");
+  expect(screen.queryByRole("region", { name: "PR submissions" })).toBeNull();
+  await user.click(screen.getByRole("tab", { name: "Pull requests" }));
+  await screen.findByRole("button", { name: "Submit PR" });
+  expect(
+    screen.queryByRole("button", { name: "Edit example-org/project" }),
+  ).toBeNull();
+  await user.click(screen.getByRole("button", { name: "Submit PR" }));
+  expect(
+    screen.queryByRole("combobox", { name: "Repository to review" }),
+  ).toBeNull();
+  expect(
+    screen
+      .getByRole("tab", { name: "Configuration" })
+      .getAttribute("aria-disabled"),
+  ).toBe("true");
+  expect(
+    (
+      screen.getByRole("button", {
+        name: "All repositories",
+      }) as HTMLButtonElement
+    ).disabled,
+  ).toBe(true);
+  await user.click(screen.getByRole("button", { name: "Cancel" }));
+  await user.click(screen.getByRole("tab", { name: "Configuration" }));
+  await user.click(
+    screen.getByRole("button", { name: "Edit example-org/project" }),
+  );
+  expect(
+    screen
+      .getByRole("tab", { name: "Pull requests" })
+      .getAttribute("aria-disabled"),
+  ).toBe("true");
+  await user.click(screen.getByRole("button", { name: /^General/ }));
+  const field = screen.getByRole("textbox", { name: "Lane 1 instructions" });
+  await user.clear(field);
+  await user.type(field, "Preserve collapsed drafts");
+  await user.click(screen.getByRole("button", { name: /^General/ }));
+  await user.click(screen.getByRole("button", { name: /^General/ }));
+  expect(
+    (
+      screen.getByRole("textbox", {
+        name: "Lane 1 instructions",
+      }) as HTMLTextAreaElement
+    ).value,
+  ).toBe("Preserve collapsed drafts");
+  await user.click(screen.getByRole("button", { name: "Cancel" }));
+  await user.click(screen.getByRole("button", { name: "All repositories" }));
+  await user.click(
+    screen.getByRole("button", { name: "Open example-org/project" }),
+  );
+  expect(
+    screen
+      .getByRole("tab", { name: "Configuration" })
+      .getAttribute("aria-selected"),
+  ).toBe("true");
+});
+
+it("blocks editor entry while a reload can replace the repository", async () => {
+  const test = fixture();
+  render(<ReviewConfigurationCommunity session={test.session} />);
+  const user = await openDraft();
+  await user.click(screen.getByRole("button", { name: "Save settings" }));
+  await screen.findByText("Saved example-org/project.");
+  let finish!: (events: EventData[]) => void;
+  test.snapshotRead.mockImplementationOnce(
+    () =>
+      new Promise((resolve) => {
+        finish = resolve;
+      }),
+  );
+  await user.click(screen.getByRole("button", { name: "Reload" }));
+  try {
+    expect(
+      (
+        screen.getByRole("button", {
+          name: "Edit example-org/project",
+        }) as HTMLButtonElement
+      ).disabled,
+    ).toBe(true);
+  } finally {
+    await act(async () => finish([]));
+  }
+  await screen.findByRole("button", { name: "Register repository" });
+  expect(
+    (
+      screen.getByRole("combobox", {
+        name: "Review channel",
+      }) as HTMLButtonElement
+    ).disabled,
+  ).toBe(false);
+});
+
+it("maps a pasted URL to its configured repository and keeps unknown URLs editable", async () => {
+  const test = fixture();
+  const readPull = vi.fn(async () => ({
+    title: "Review this change",
+    labels: [],
+    changedFiles: 1,
+    repository: "example-org/project",
+    pr: 42,
+    paths: ["src/index.ts"],
+    head: "a".repeat(40),
+    base: "b".repeat(40),
+  }));
+  render(
+    <ReviewConfigurationCommunity session={test.session} readPull={readPull} />,
+  );
+  const user = await openDraft();
+  await user.click(screen.getByRole("button", { name: "Save settings" }));
+  await screen.findByText("Saved example-org/project.");
+  await user.click(screen.getByRole("button", { name: "All repositories" }));
+  await user.click(screen.getByRole("button", { name: "Submit PR" }));
+  const input = screen.getByRole("textbox", { name: "GitHub PR URL" });
+  await user.type(input, "https://github.com/example-org/unknown/pull/42");
+  await user.click(screen.getByRole("button", { name: "Continue" }));
+  expect((await screen.findByRole("alert")).textContent).toContain(
+    "not configured",
+  );
+  await user.clear(input);
+  await user.type(input, "https://github.com/example-org/project/pull/42");
+  await user.click(screen.getByRole("button", { name: "Continue" }));
+  expect(
+    (
+      (await screen.findByRole("textbox", {
+        name: "Pull request",
+      })) as HTMLInputElement
+    ).value,
+  ).toBe("https://github.com/example-org/project/pull/42");
+  await user.click(screen.getByRole("button", { name: "Load PR details" }));
+  await waitFor(() =>
+    expect(readPull).toHaveBeenCalledWith(
+      "example-org/project",
+      42,
+      expect.any(AbortSignal),
+    ),
+  );
+  expect(test.publish).toHaveBeenCalledTimes(1);
+  await user.click(screen.getByRole("button", { name: "Cancel" }));
+  await user.click(screen.getByRole("tab", { name: "Configuration" }));
+  await user.click(screen.getByRole("tab", { name: "Pull requests" }));
+  expect(screen.queryByRole("textbox", { name: "Pull request" })).toBeNull();
+});
diff --git a/src/bundled/review-configuration/ReviewConfigurationPage.tsx b/src/bundled/review-configuration/ReviewConfigurationPage.tsx
index e123fdbe78..4b2fb31d3e 100644
--- a/src/bundled/review-configuration/ReviewConfigurationPage.tsx
+++ b/src/bundled/review-configuration/ReviewConfigurationPage.tsx
@@ -1,9 +1,16 @@
 import { createPullReader, type ReadPull } from "./pull-facts";
 const publicPullReader = createPullReader();
 import { LaneRules } from "./LaneRules";
-import { useEffect, useRef, useState, type ReactNode } from "react";
+import {
+  useCallback,
+  useEffect,
+  useRef,
+  useState,
+  type ReactNode,
+} from "react";
 import { useAgentChoices } from "../../features/agents/use-choices";
 import { ReviewSubmissions } from "./ReviewSubmissions";
+import { pullRepository } from "./submissions";
 import type { Navigation } from "../../features/navigation/controller";
 import { splitPartition } from "../../features/relay/partition";
 import { LaneReviewers } from "./LaneReviewers";
@@ -11,6 +18,9 @@ import { useChannelList, useRelayConnection } from "../../features/relay/react";
 import type { RelayData } from "../../features/relay/service";
 import type { RelaySession } from "../../features/relay/session";
 import { ListChecksIcon } from "../../shared/design-system/icons";
+import { Accordion } from "../../shared/design-system/ui/Accordion";
+import { NavigationItem } from "../../shared/design-system/ui/NavigationItem";
+import { Tabs } from "../../shared/design-system/ui/Tabs";
 import { Button } from "../../shared/design-system/ui/Button";
 import { Field } from "../../shared/design-system/ui/Field";
 import { FullPageSurface } from "../../shared/design-system/ui/FullPageSurface";
@@ -153,11 +163,6 @@ export function ReviewConfigurationCommunity({
     !!session.configArtifactWriter;
   return (
     <Frame>
-      <p>
-        Register repositories and save their review lane instructions. These are
-        saved settings; use Submit PR below to start reviewer threads. Saving
-        settings does not send messages.
-      </p>
       <Select
         label="Review channel"
         variant="field"
@@ -174,7 +179,7 @@ export function ReviewConfigurationCommunity({
             })),
           },
         ]}
-        description="Settings are shared with this channel. Members who can post can edit them. Choose a private channel for private instructions."
+        description="Repositories and reviews are shared with this channel."
       />
       {list.status === "loading" && <p role="status">Loading channels…</p>}
       {list.status === "error" && (
@@ -217,6 +222,14 @@ function ChannelConfiguration({
   onOpenThread?: ((channel: string, id: string) => Promise<void>) | undefined;
 }) {
   const [submitting, setSubmitting] = useState(false);
+  const [lookup, setLookup] = useState(false);
+  const [pullUrl, setPullUrl] = useState("");
+  const [lookupError, setLookupError] = useState("");
+  const [initialPull, setInitialPull] = useState("");
+  const submissionEditing = useCallback((editing: boolean) => {
+    setSubmitting(editing);
+    if (!editing) setInitialPull("");
+  }, []);
   const [rows, setRows] = useState<SavedReviewConfig[]>([]);
   const [loading, setLoading] = useState(true);
   const [error, setError] = useState("");
@@ -225,12 +238,17 @@ function ChannelConfiguration({
   const [remaining, setRemaining] = useState(0);
   const [reload, setReload] = useState(0);
   const [editor, setEditor] = useState<SavedReviewConfig | "new">();
+  const [repository, setRepository] = useState("");
+  const [section, setSection] = useState<"configuration" | "pulls">(
+    "configuration",
+  );
+  const selected = rows.find((row) => row.config.repository === repository);
   const editorTrigger = useRef<HTMLButtonElement | null>(null);
   useEffect(() => {
-    onEditingChange(editor !== undefined || submitting);
+    onEditingChange(editor !== undefined || submitting || lookup);
     if (editor === undefined) editorTrigger.current?.focus();
     return () => onEditingChange(false);
-  }, [editor, submitting, onEditingChange]);
+  }, [editor, submitting, lookup, onEditingChange]);
   // biome-ignore lint/correctness/useExhaustiveDependencies: Reload explicitly requests a fresh snapshot.
   useEffect(() => {
     const controller = new AbortController();
@@ -274,132 +292,280 @@ function ChannelConfiguration({
       });
     return () => controller.abort();
   }, [session, channel, reload]);
+  function saved(next: SavedReviewConfig) {
+    if (editor === "new") setRemaining((value) => value - 1);
+    setRows((current) =>
+      [
+        ...current.filter((row) => row.artifactId !== next.artifactId),
+        next,
+      ].sort((a, b) => a.config.repository.localeCompare(b.config.repository)),
+    );
+    setRepository(next.config.repository);
+    setEditor(undefined);
+    setNotice(`Saved ${next.config.repository}.`);
+  }
   return (
     <>
-      <InlineHeader title="Repositories" />
-      <div className="review-config-actions">
-        <Button
-          disabled={loading || !!editor || submitting}
-          onClick={() => {
-            setNotice("");
-            setReload((value) => value + 1);
-          }}
-        >
-          Reload
-        </Button>
-        <Button
-          variant="prominent"
-          disabled={
-            loading ||
-            !!error ||
-            !!editor ||
-            submitting ||
-            !writable ||
-            remaining <= 0
-          }
-          onClick={(event) => {
-            editorTrigger.current = event.currentTarget;
-            setNotice("");
-            setEditor("new");
-          }}
-        >
-          Register repository
-        </Button>
-      </div>
-      {!session.configArtifactWriter && (
-        <p role="alert">
-          This connection cannot save settings. Reconnect with a supported Buzz
-          client.
-        </p>
-      )}
-      {!loading && !error && warning && <p role="alert">{warning}</p>}
-      {loading ? (
-        <p role="status">Loading configurations…</p>
-      ) : error ? (
-        <p role="alert">{error} Use Reload to try again.</p>
-      ) : rows.length ? (
-        <table className="review-config-table">
-          <caption className="sr-only">Saved repository configurations</caption>
-          <thead>
-            <tr>
-              <th scope="col">Repository</th>
-              <th scope="col">Lanes</th>
-              <th scope="col">Settings</th>
-            </tr>
-          </thead>
-          <tbody>
-            {rows.map((row) => (
-              <tr key={row.artifactId}>
-                <th scope="row">{row.config.repository}</th>
-                <td>
-                  {row.config.lanes
-                    .map(
-                      (lane) =>
-                        `${lane.name} (${lane.reviewers.length} ${lane.reviewers.length === 1 ? "reviewer" : "reviewers"})`,
-                    )
-                    .join(", ")}
-                </td>
-                <td>
-                  <Button
-                    aria-label={`Edit ${row.config.repository}`}
-                    disabled={!!editor || submitting || !writable}
-                    onClick={(event) => {
-                      editorTrigger.current = event.currentTarget;
-                      setNotice("");
-                      setEditor(row);
-                    }}
-                  >
-                    Edit
-                  </Button>
-                </td>
-              </tr>
-            ))}
-          </tbody>
-        </table>
+      {!selected && editor !== "new" ? (
+        <>
+          <InlineHeader title="Repositories" />
+          <div className="review-config-actions">
+            <Button
+              disabled={loading || lookup}
+              onClick={() => setReload((value) => value + 1)}
+            >
+              Reload
+            </Button>
+            <Button
+              ref={editorTrigger}
+              variant="prominent"
+              disabled={
+                loading || lookup || !!error || !writable || remaining <= 0
+              }
+              onClick={(event) => {
+                editorTrigger.current = event.currentTarget;
+                setNotice("");
+                setEditor("new");
+              }}
+            >
+              Register repository
+            </Button>
+            <Button
+              disabled={
+                loading || lookup || !!error || !writable || !rows.length
+              }
+              onClick={() => {
+                setLookup(true);
+                setLookupError("");
+              }}
+            >
+              Submit PR
+            </Button>
+          </div>
+          {lookup && (
+            <form
+              className="review-config-form"
+              onSubmit={(event) => {
+                event.preventDefault();
+                try {
+                  const name = pullRepository(pullUrl);
+                  const match = rows.find(
+                    (row) => row.config.repository === name,
+                  );
+                  if (!match)
+                    throw new Error(
+                      `${name} is not configured in this channel. Register it before submitting.`,
+                    );
+                  setRepository(name);
+                  setSection("pulls");
+                  setInitialPull(pullUrl.trim());
+                  setLookup(false);
+                } catch (reason) {
+                  setLookupError(
+                    reason instanceof Error
+                      ? reason.message
+                      : "Could not find repository.",
+                  );
+                }
+              }}
+            >
+              <Field
+                label="GitHub PR URL"
+                description="We’ll find its configured repository and match its lane rules."
+              >
+                <Input
+                  autoFocus
+                  required
+                  maxLength={300}
+                  value={pullUrl}
+                  onValueChange={setPullUrl}
+                  placeholder="https://github.com/example-org/project/pull/123"
+                />
+              </Field>
+              {lookupError && <p role="alert">{lookupError}</p>}
+              <div className="review-config-actions">
+                <Button onClick={() => setLookup(false)}>Cancel</Button>
+                <Button type="submit" variant="prominent">
+                  Continue
+                </Button>
+              </div>
+            </form>
+          )}
+          {loading ? (
+            <p role="status">Loading configurations…</p>
+          ) : error ? (
+            <p role="alert">{error} Use Reload to try again.</p>
+          ) : rows.length ? (
+            <div className="review-config-repositories">
+              {rows.map((row) => (
+                <NavigationItem
+                  key={row.artifactId}
+                  aria-label={`Open ${row.config.repository}`}
+                  multiline
+                  disabled={lookup}
+                  label={
+                    <span className="review-config-repository-label">
+                      <span>{row.config.repository}</span>
+                      <span className="text-caption text-subtle">
+                        {row.config.lanes.map((lane) => lane.name).join(" · ")}
+                      </span>
+                    </span>
+                  }
+                  trailing="Open"
+                  onClick={() => {
+                    setRepository(row.config.repository);
+                    setSection("configuration");
+                    setNotice("");
+                  }}
+                />
+              ))}
+            </div>
+          ) : (
+            <p>
+              {warning
+                ? "No readable configurations in this channel."
+                : "No repositories configured in this channel. Register one to save its review lanes."}
+            </p>
+          )}
+          {warning && <p role="alert">{warning}</p>}
+        </>
       ) : (
-        <p>
-          {warning
-            ? "No readable configurations in this channel."
-            : "No repositories configured in this channel. Register one to save its review lanes."}
-        </p>
+        <>
+          <div>
+            <Button
+              disabled={!!editor || submitting}
+              onClick={() => {
+                setRepository("");
+                setNotice("");
+              }}
+            >
+              All repositories
+            </Button>
+          </div>
+          {selected && (
+            <>
+              <InlineHeader title={selected.config.repository} />
+              <Tabs
+                variant="panel"
+                label="Repository sections"
+                value={section}
+                items={[
+                  {
+                    value: "configuration",
+                    label: "Configuration",
+                    disabled: !!editor || submitting,
+                  },
+                  {
+                    value: "pulls",
+                    label: "Pull requests",
+                    disabled: !!editor || submitting,
+                  },
+                ]}
+                onValueChange={setSection}
+                renderPanel={(tab) =>
+                  tab === "configuration" ? (
+                    <section
+                      className="review-config-form"
+                      aria-label="Repository configuration"
+                    >
+                      {editor ? (
+                        <ConfigurationEditor
+                          key={editor === "new" ? "new" : editor.revision}
+                          session={session}
+                          channel={channel}
+                          writable={writable}
+                          previous={editor === "new" ? undefined : editor}
+                          existing={rows}
+                          onCancel={() => setEditor(undefined)}
+                          onSaved={saved}
+                        />
+                      ) : (
+                        <>
+                          <div className="review-config-actions">
+                            <Button
+                              ref={editorTrigger}
+                              variant="prominent"
+                              disabled={!writable || loading || !!error}
+                              aria-label={`Edit ${selected.config.repository}`}
+                              onClick={(event) => {
+                                editorTrigger.current = event.currentTarget;
+                                setNotice("");
+                                setEditor(selected);
+                              }}
+                            >
+                              Edit configuration
+                            </Button>
+                            <Button
+                              disabled={loading}
+                              onClick={() => {
+                                setNotice("");
+                                setReload((value) => value + 1);
+                              }}
+                            >
+                              Reload
+                            </Button>
+                          </div>
+                          {error && <p role="alert">{error}</p>}
+                          <Accordion
+                            variant="form"
+                            items={selected.config.lanes.map((lane) => ({
+                              value: lane.id,
+                              title: (
+                                <span className="review-config-pr-summary">
+                                  <span>{lane.name}</span>
+                                  <span className="text-caption text-subtle">
+                                    {lane.reviewers.length}{" "}
+                                    {lane.reviewers.length === 1
+                                      ? "reviewer"
+                                      : "reviewers"}{" "}
+                                    ·{" "}
+                                    {lane.routing?.rules.length
+                                      ? `${lane.routing.rules.length} routing rules`
+                                      : "All PRs"}
+                                  </span>
+                                </span>
+                              ),
+                              content: (
+                                <p className="review-config-instructions">
+                                  {lane.instructions}
+                                </p>
+                              ),
+                            }))}
+                          />
+                        </>
+                      )}
+                    </section>
+                  ) : (
+                    <ReviewSubmissions
+                      session={session}
+                      channel={channel}
+                      configurations={[selected]}
+                      initialPull={initialPull}
+                      disabled={loading || !!error}
+                      writable={writable}
+                      onEditingChange={submissionEditing}
+                      onOpenThread={onOpenThread}
+                      readPull={readPull}
+                    />
+                  )
+                }
+              />
+            </>
+          )}
+          {editor === "new" && (
+            <ConfigurationEditor
+              session={session}
+              channel={channel}
+              writable={writable}
+              previous={undefined}
+              existing={rows}
+              onCancel={() => setEditor(undefined)}
+              onSaved={saved}
+            />
+          )}
+        </>
       )}
       {notice && <p role="status">{notice}</p>}
-      {editor && (
-        <ConfigurationEditor
-          key={editor === "new" ? "new" : editor.revision}
-          session={session}
-          channel={channel}
-          writable={writable}
-          previous={editor === "new" ? undefined : editor}
-          existing={rows}
-          onCancel={() => setEditor(undefined)}
-          onSaved={(saved) => {
-            if (editor === "new") setRemaining((value) => value - 1);
-            setRows((current) =>
-              [
-                ...current.filter((row) => row.artifactId !== saved.artifactId),
-                saved,
-              ].sort((a, b) =>
-                a.config.repository.localeCompare(b.config.repository),
-              ),
-            );
-            setEditor(undefined);
-            setNotice(
-              `Saved ${saved.config.repository}. Use Submit PR to start review threads.`,
-            );
-          }}
-        />
-      )}
-      <ReviewSubmissions
-        session={session}
-        channel={channel}
-        configurations={rows}
-        disabled={!!editor || loading || !!error}
-        writable={writable}
-        onEditingChange={setSubmitting}
-        onOpenThread={onOpenThread}
-        readPull={readPull}
-      />
     </>
   );
 }
@@ -440,6 +606,11 @@ function ConfigurationEditor({
         ],
       },
   );
+  const editorRegion = useRef<HTMLFormElement>(null);
+  useEffect(() => {
+    if (previous) editorRegion.current?.focus();
+  }, [previous]);
+  const [expanded, setExpanded] = useState<string[]>([]);
   const [busy, setBusy] = useState(false);
   const [error, setError] = useState("");
   const operation = useRef<AbortController | undefined>(undefined);
@@ -469,10 +640,12 @@ function ConfigurationEditor({
       );
       if (!controller.signal.aborted) onSaved(result);
     } catch (reason) {
-      if (!controller.signal.aborted)
+      if (!controller.signal.aborted) {
+        setExpanded(draft.lanes.map((lane) => lane.id));
         setError(
           `${reason instanceof Error ? reason.message : "Could not save settings."} Your draft is still here. If settings changed elsewhere or the save timed out, copy your changes, then Cancel and Reload before retrying.`,
         );
+      }
     } finally {
       operation.current = undefined;
       if (!controller.signal.aborted) setBusy(false);
@@ -480,32 +653,36 @@ function ConfigurationEditor({
   }
   return (
     <form
+      ref={editorRegion}
+      tabIndex={-1}
+      aria-label="Edit repository settings"
+      noValidate
       onSubmit={(event) => {
         event.preventDefault();
         void save();
       }}
       className="review-config-form"
     >
-      <InlineHeader
-        title={previous ? "Edit repository" : "Register repository"}
-      />
-      <SettingsGroup layout="form">
-        <Field
-          label="GitHub repository"
-          description="Use owner/repository or the full repository URL."
-        >
-          <Input
-            autoFocus
-            required
-            value={draft.repository}
-            readOnly={!!previous}
-            disabled={busy}
-            maxLength={250}
-            placeholder="example-org/project"
-            onValueChange={(repository) => setDraft({ ...draft, repository })}
-          />
-        </Field>
-      </SettingsGroup>
+      {!previous && <InlineHeader title="Register repository" />}
+      {!previous && (
+        <SettingsGroup layout="form">
+          <Field
+            label="GitHub repository"
+            description="Use owner/repository or the full repository URL."
+          >
+            <Input
+              autoFocus
+              required
+              value={draft.repository}
+              readOnly={!!previous}
+              disabled={busy}
+              maxLength={250}
+              placeholder="example-org/project"
+              onValueChange={(repository) => setDraft({ ...draft, repository })}
+            />
+          </Field>
+        </SettingsGroup>
+      )}
       {choices.pending && <p role="status">Loading reviewer agents…</p>}
       {!choices.pending && !choices.selectable.length && (
         <p>
@@ -545,116 +722,151 @@ function ConfigurationEditor({
           Refresh agents
         </Button>
       </div>
-      {draft.lanes.map((lane, index) => (
-        <section key={lane.id} className="review-config-lane">
-          <div className="review-config-actions">
-            <InlineHeader title={`Lane ${index + 1}`} />
-            <Button
-              disabled={busy || draft.lanes.length === 1}
-              onClick={() =>
-                setDraft({
-                  ...draft,
-                  lanes: draft.lanes.filter((item) => item.id !== lane.id),
-                })
-              }
-            >
-              Remove lane {index + 1}
-            </Button>
-          </div>
-          <SettingsGroup layout="form">
-            <Field label={`Lane ${index + 1} name`}>
-              <Input
-                required
-                maxLength={80}
-                disabled={busy}
-                value={lane.name}
-                onValueChange={(name) =>
-                  setDraft({
-                    ...draft,
-                    lanes: draft.lanes.map((item) =>
-                      item.id === lane.id ? { ...item, name } : item,
+      <Accordion
+        variant="form"
+        keepMounted
+        value={expanded}
+        onValueChange={setExpanded}
+        items={draft.lanes.map((lane, index) => ({
+          value: lane.id,
+          title: (
+            <span className="review-config-pr-summary">
+              <span>{lane.name || `Lane ${index + 1}`}</span>
+              <span className="text-caption text-subtle">
+                {lane.reviewers.length}{" "}
+                {lane.reviewers.length === 1 ? "reviewer" : "reviewers"} ·{" "}
+                {lane.routing?.rules.length
+                  ? `${lane.routing.rules.length} rules`
+                  : "All PRs"}
+              </span>
+            </span>
+          ),
+          content: (
+            <section className="review-config-lane">
+              <div className="review-config-actions">
+                <Button
+                  disabled={busy || draft.lanes.length === 1}
+                  onClick={() =>
+                    setDraft({
+                      ...draft,
+                      lanes: draft.lanes.filter((item) => item.id !== lane.id),
+                    })
+                  }
+                >
+                  Remove lane {index + 1}
+                </Button>
+              </div>
+              <SettingsGroup layout="form">
+                <Field label={`Lane ${index + 1} name`}>
+                  <Input
+                    required
+                    maxLength={80}
+                    disabled={busy}
+                    value={lane.name}
+                    onValueChange={(name) =>
+                      setDraft({
+                        ...draft,
+                        lanes: draft.lanes.map((item) =>
+                          item.id === lane.id ? { ...item, name } : item,
+                        ),
+                      })
+                    }
+                  />
+                </Field>
+                <LaneReviewers
+                  lane={index + 1}
+                  reviewers={lane.reviewers}
+                  choices={choices}
+                  disabled={busy}
+                  onChange={(reviewers) =>
+                    setDraft({
+                      ...draft,
+                      lanes: draft.lanes.map((item) =>
+                        item.id === lane.id ? { ...item, reviewers } : item,
+                      ),
+                    })
+                  }
+                />
+                <Field
+                  label={`Lane ${index + 1} instructions`}
+                  description="Save the instructions reviewers should receive for this lane."
+                >
+                  <Textarea
+                    required
+                    rows={3}
+                    maxLength={8000}
+                    disabled={busy}
+                    value={lane.instructions}
+                    onChange={(event) =>
+                      setDraft({
+                        ...draft,
+                        lanes: draft.lanes.map((item) =>
+                          item.id === lane.id
+                            ? { ...item, instructions: event.target.value }
+                            : item,
+                        ),
+                      })
+                    }
+                  />
+                </Field>
+              </SettingsGroup>
+              <Accordion
+                variant="form"
+                keepMounted
+                items={[
+                  {
+                    value: "routing",
+                    title: `Routing rules (${lane.routing?.rules.length ?? 0})`,
+                    content: (
+                      <div className="review-config-form">
+                        {" "}
+                        <LaneRules
+                          lane={index + 1}
+                          value={lane.routing}
+                          disabled={busy}
+                          onChange={(routing) =>
+                            setDraft({
+                              ...draft,
+                              lanes: draft.lanes.map((item) =>
+                                item.id === lane.id
+                                  ? { ...item, routing }
+                                  : item,
+                              ),
+                            })
+                          }
+                        />
+                      </div>
                     ),
-                  })
-                }
+                  },
+                ]}
               />
-            </Field>
-            <LaneRules
-              lane={index + 1}
-              value={lane.routing}
-              disabled={busy}
-              onChange={(routing) =>
-                setDraft({
-                  ...draft,
-                  lanes: draft.lanes.map((item) =>
-                    item.id === lane.id ? { ...item, routing } : item,
-                  ),
-                })
-              }
-            />
-            <LaneReviewers
-              lane={index + 1}
-              reviewers={lane.reviewers}
-              choices={choices}
-              disabled={busy}
-              onChange={(reviewers) =>
-                setDraft({
-                  ...draft,
-                  lanes: draft.lanes.map((item) =>
-                    item.id === lane.id ? { ...item, reviewers } : item,
-                  ),
-                })
-              }
-            />
-            <Field
-              label={`Lane ${index + 1} instructions`}
-              description="Save the instructions reviewers should receive for this lane."
-            >
-              <Textarea
-                required
-                rows={5}
-                maxLength={8000}
-                disabled={busy}
-                value={lane.instructions}
-                onChange={(event) =>
-                  setDraft({
-                    ...draft,
-                    lanes: draft.lanes.map((item) =>
-                      item.id === lane.id
-                        ? { ...item, instructions: event.target.value }
-                        : item,
-                    ),
-                  })
-                }
-              />
-            </Field>
-          </SettingsGroup>
-        </section>
-      ))}
+            </section>
+          ),
+        }))}
+      />
       <div>
         <Button
           disabled={busy || draft.lanes.length >= 12}
-          onClick={() =>
+          onClick={() => {
+            const id = crypto.randomUUID();
+            setExpanded([id]);
             setDraft({
               ...draft,
               lanes: [
                 ...draft.lanes,
                 {
-                  id: crypto.randomUUID(),
+                  id,
                   name: "",
                   instructions: "",
                   reviewers: [],
                 },
               ],
-            })
-          }
+            });
+          }}
         >
           Add lane
         </Button>
       </div>
-      <p>
-        Reminder interval: 15 minutes. Automatic reminder delivery will be
-        available in a later version.
-      </p>
       {error && <p role="alert">{error}</p>}
       <div className="review-config-actions">
         <Button disabled={busy} onClick={onCancel}>
diff --git a/src/bundled/review-configuration/ReviewSubmissions.tsx b/src/bundled/review-configuration/ReviewSubmissions.tsx
index e0b724b197..8cae8ed670 100644
--- a/src/bundled/review-configuration/ReviewSubmissions.tsx
+++ b/src/bundled/review-configuration/ReviewSubmissions.tsx
@@ -25,6 +25,7 @@ export function ReviewSubmissions({
   session,
   channel,
   configurations,
+  initialPull = "",
   disabled,
   writable,
   onEditingChange,
@@ -35,6 +36,7 @@ export function ReviewSubmissions({
   readPull?: ReadPull;
   channel: string;
   configurations: readonly SavedReviewConfig[];
+  initialPull?: string;
   disabled: boolean;
   writable: boolean;
   onEditingChange: (editing: boolean) => void;
@@ -45,10 +47,17 @@ export function ReviewSubmissions({
   const [loading, setLoading] = useState(true);
   const [error, setError] = useState("");
   const [warning, setWarning] = useState("");
-  const [draft, setDraft] = useState<{
-    config: SavedReviewConfig;
-    existing?: SavedSubmission;
-  }>();
+  const [draft, setDraft] = useState<
+    | {
+        config: SavedReviewConfig;
+        existing?: SavedSubmission;
+      }
+    | undefined
+  >(() =>
+    initialPull && configurations[0]
+      ? { config: configurations[0] }
+      : undefined,
+  );
   const trigger = useRef<HTMLButtonElement | null>(null);
   useEffect(() => {
     onEditingChange(!!draft);
@@ -84,16 +93,16 @@ export function ReviewSubmissions({
       });
     return () => controller.abort();
   }, [session, channel, reload]);
+  const visibleRows = rows.filter((row) =>
+    configurations.some(
+      (config) => config.config.repository === row.value.config.repository,
+    ),
+  );
   return (
     <section className="review-config-form" aria-label="PR submissions">
-      <InlineHeader title="Submit a PR" />
-      <p>
-        Submit a PR to start reviewer conversations using saved settings.
-        Delivery does not confirm that a reviewer is running. Automatic
-        reminders are off.
-      </p>
       <div className="review-config-actions">
         <Button
+          ref={trigger}
           variant="prominent"
           disabled={
             disabled ||
@@ -118,9 +127,10 @@ export function ReviewSubmissions({
           channel={channel}
           configurations={configurations}
           initial={draft.config}
+          initialPull={initialPull}
           readPull={readPull}
           existing={draft.existing}
-          writable={writable}
+          writable={writable && !loading && !error}
           onClose={() => setDraft(undefined)}
           onProgress={(record) =>
             setRows((current) => [
@@ -145,12 +155,12 @@ export function ReviewSubmissions({
           <p role="alert">{error} Use Reload submissions to try again.</p>
         )}
         {warning && <p role="alert">{warning}</p>}
-        {!loading && !error && !rows.length && (
-          <p>No PRs submitted in this channel.</p>
+        {!loading && !error && !visibleRows.length && (
+          <p>No PRs submitted for this repository.</p>
         )}
         <Accordion
           variant="form"
-          items={rows.map((row) => ({
+          items={visibleRows.map((row) => ({
             value: row.artifactId,
             title: (
               <span className="review-config-pr-summary">
@@ -242,6 +252,7 @@ function SubmissionForm({
   channel,
   configurations,
   initial,
+  initialPull,
   existing,
   writable,
   onClose,
@@ -253,6 +264,7 @@ function SubmissionForm({
   channel: string;
   configurations: readonly SavedReviewConfig[];
   initial: SavedReviewConfig;
+  initialPull: string;
   existing: SavedSubmission | undefined;
   writable: boolean;
   onClose: () => void;
@@ -260,7 +272,9 @@ function SubmissionForm({
 }) {
   const choices = useAgentChoices(session, true, true);
   const [config, setConfig] = useState(initial);
-  const [pr, setPr] = useState(existing ? String(existing.value.pr) : "");
+  const [pr, setPr] = useState(
+    existing ? String(existing.value.pr) : initialPull,
+  );
   const [reviewers, setReviewers] = useState(
     initial.config.lanes.map((lane) => lane.reviewers[0] ?? ""),
   );
@@ -374,33 +388,35 @@ function SubmissionForm({
         title={started ? "Resume saved submission" : "New PR submission"}
       />
       <SettingsGroup layout="form">
-        <Select
-          label="Repository to review"
-          variant="field"
-          value={config.config.repository}
-          disabled={busy || reading || started}
-          groups={[
-            {
-              label: "Repositories",
-              options: (existing ? [config] : configurations).map((row) => ({
-                value: row.config.repository,
-                label: row.config.repository,
-              })),
-            },
-          ]}
-          onValueChange={(repository) => {
-            const row = configurations.find(
-              (item) => item.config.repository === repository,
-            );
-            if (row) {
-              setFacts(undefined);
-              setConfig(row);
-              setReviewers(
-                row.config.lanes.map((lane) => lane.reviewers[0] ?? ""),
+        {configurations.length > 1 && (
+          <Select
+            label="Repository to review"
+            variant="field"
+            value={config.config.repository}
+            disabled={busy || reading || started}
+            groups={[
+              {
+                label: "Repositories",
+                options: (existing ? [config] : configurations).map((row) => ({
+                  value: row.config.repository,
+                  label: row.config.repository,
+                })),
+              },
+            ]}
+            onValueChange={(repository) => {
+              const row = configurations.find(
+                (item) => item.config.repository === repository,
               );
-            }
-          }}
-        />
+              if (row) {
+                setFacts(undefined);
+                setConfig(row);
+                setReviewers(
+                  row.config.lanes.map((lane) => lane.reviewers[0] ?? ""),
+                );
+              }
+            }}
+          />
+        )}
         <Field
           label="Pull request"
           description="Enter a PR number or full GitHub PR URL, then load its details to preview matching lanes."
diff --git a/src/bundled/review-configuration/review-configuration.css b/src/bundled/review-configuration/review-configuration.css
index 0c95b66e77..d947623818 100644
--- a/src/bundled/review-configuration/review-configuration.css
+++ b/src/bundled/review-configuration/review-configuration.css
@@ -35,19 +35,6 @@
   flex-wrap: wrap;
   gap: var(--space-2);
 }
-.review-config-table {
-  width: 100%;
-  table-layout: fixed;
-  border-collapse: collapse;
-}
-.review-config-table th,
-.review-config-table td {
-  text-align: start;
-  overflow-wrap: anywhere;
-  padding: var(--space-2);
-  border-bottom: 1px solid var(--border-standard);
-}
-
 .review-config-instructions {
   white-space: pre-wrap;
   overflow-wrap: anywhere;
@@ -60,3 +47,28 @@
   gap: var(--space-2) var(--space-4);
   overflow-wrap: anywhere;
 }
+
+.review-config-repositories,
+.review-config-repository-label {
+  display: flex;
+  flex-direction: column;
+  min-width: 0;
+  gap: var(--space-2);
+}
+.review-config-rule {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: var(--space-3);
+  align-items: start;
+}
+.review-config-rule > :nth-child(3) {
+  grid-column: 1 / -1;
+}
+.review-config-form {
+  overflow-wrap: anywhere;
+}
+@media (max-width: 480px) {
+  .review-config-rule {
+    grid-template-columns: minmax(0, 1fr);
+  }
+}
diff --git a/src/bundled/review-configuration/submissions.test.ts b/src/bundled/review-configuration/submissions.test.ts
index d2dd34e0d8..f5e55c8b1c 100644
--- a/src/bundled/review-configuration/submissions.test.ts
+++ b/src/bundled/review-configuration/submissions.test.ts
@@ -5,7 +5,12 @@ import { createOutbox, type OutgoingEvent } from "../../features/relay/outbox";
 import type { EventData, ReadFilter } from "../../features/relay/events";
 import type { RelaySession } from "../../features/relay/session";
 import { keypair, signed } from "../../features/relay/testing";
-import { loadSubmissions, pullRequest, submitReview } from "./submissions";
+import {
+  loadSubmissions,
+  pullRequest,
+  pullRepository,
+  submitReview,
+} from "./submissions";
 import type { SavedReviewConfig } from "./configuration";
 
 const channel = "11111111-1111-4111-8111-111111111111";
@@ -473,3 +478,17 @@ it("retains old overview and lane IDs when reloading and resuming a version-one
   expect(resumed.value.threads.every((thread) => thread.delivered)).toBe(true);
   expect(f.publish).toHaveBeenCalledTimes(2);
 });
+
+it("infers a canonical repository only from a valid full PR URL", () => {
+  expect(
+    pullRepository(" https://github.com/Example-Org/Project/pull/12/ "),
+  ).toBe("example-org/project");
+  for (const input of [
+    "12",
+    "https://example.org/a/b/pull/12",
+    "https://github.com/a/b/pull/0",
+    "https://github.com/a/b/pull/9007199254740992",
+    "https://user@github.com/a/b/pull/12",
+  ])
+    expect(() => pullRepository(input)).toThrow();
+});
diff --git a/src/bundled/review-configuration/submissions.ts b/src/bundled/review-configuration/submissions.ts
index eca124c963..753bee17bb 100644
--- a/src/bundled/review-configuration/submissions.ts
+++ b/src/bundled/review-configuration/submissions.ts
@@ -43,6 +43,19 @@ export const prUrl = (value: Submission) =>
 export const threadUrl = (channel: string, id: string) =>
   `buzz://message?channel=${channel}&id=${id}`;
 
+/** A global PR entry requires a full URL so the configured repository is unambiguous. */
+export function pullRepository(input: string): string {
+  const match =
+    /^https:\/\/github\.com\/([^/]+\/[^/]+)\/pull\/([1-9]\d*)\/?$/i.exec(
+      input.trim(),
+    );
+  if (!match)
+    throw new Error("Enter a full GitHub PR URL to find its repository.");
+  const repository = repositoryName(match[1] ?? "");
+  pullRequest(input, repository);
+  return repository;
+}
+
 export function pullRequest(input: string, repository: string): number {
   const text = input.trim();
   const match =

From fd7ebc63ca0438567a4be1ad769c2c8d22c10a78 Mon Sep 17 00:00:00 2001
From: Ravneet Arora <rarora@squareup.com>
Date: Thu, 12 Nov 2026 12:59:19 -0500
Subject: [PATCH 06/17] Edit and save review lanes individually

Group agents and routing rules within each lane. Require a rule for new or edited lanes and preserve readable legacy settings.

Co-authored-by: maincourse <37ce551b493d4a998caf030929c47bce0b6a0e43f1178b3a63c4151d7c16b76e@buzz.block.builderlab.xyz>
Signed-off-by: Ravneet Arora <rarora@squareup.com>
---
 docs/buzz-help.md                             |  11 +-
 .../review-configuration/LaneReviewers.tsx    |  44 +-
 .../review-configuration/LaneRules.tsx        | 168 +++--
 src/bundled/review-configuration/README.md    |  10 +-
 .../ReviewConfigurationPage.test.tsx          | 245 ++++---
 .../ReviewConfigurationPage.tsx               | 621 ++++++++++--------
 .../configuration.test.ts                     |  46 +-
 .../review-configuration/configuration.ts     |  12 +
 .../review-configuration.css                  |  32 +-
 9 files changed, 728 insertions(+), 461 deletions(-)

diff --git a/docs/buzz-help.md b/docs/buzz-help.md
index 4d8abf1f31..4841709b85 100644
--- a/docs/buzz-help.md
+++ b/docs/buzz-help.md
@@ -1157,18 +1157,21 @@ confirmation. **Delete team** asks first; it doesn't delete the team's agents.
   plugins** to add its own Messages sidebar entry. Choose a review channel,
   register a GitHub repository, and save named lanes with reviewer agents and
   instructions. Each lane supports multiple reviewers. Saved
-  repositories appear in a table; **Edit** changes their settings and **Reload**
+  repositories appear in a list; open one to manage its lanes. **Reload**
   reads the latest saved versions. Settings live on the community relay and are
   visible to channel readers; members who can post can edit them. A conflicting
   edit preserves your draft: copy your changes before cancelling and reloading.
   **Submit PR** on the repository list finds the configured repository from a full
   GitHub PR URL, then opens its matching-lane preview flow.
-  Open one repository at a time. **Configuration** contains expandable lane settings;
+  Open one repository at a time. **Configuration** shows lane cards with agents, instructions, and rules;
   **Pull requests** contains **Submit PR** and that repository’s **Existing PRs**.
+  **Edit lane** opens one lane. **Save lane** persists it before **Add lane** can start another.
+  **Back to lanes** cancels the editor; **Back to repositories** returns to the list.
   Save or cancel an open draft before switching views.
   **Submit PR** accepts a PR number or URL for that repository and one reviewer
-  per matching lane. Optional all/any rules match title text, exact labels, changed-file
-  counts, and path patterns such as `src/**/*.tsx`. No rules matches every PR.
+  per matching lane. Every new or edited lane requires at least one all/any routing rule
+  matching title text, exact labels, changed-file counts, or path patterns such as `src/**/*.tsx`.
+  Earlier rule-free lanes still match every PR; editing them requires adding a rule.
   **Load PR details** previews matching lanes; zero matches sends nothing.
   **Start review threads** rechecks the PR, saves the instructions, and creates
   one thread per matching lane, mentioning its reviewer. Earlier submissions
diff --git a/src/bundled/review-configuration/LaneReviewers.tsx b/src/bundled/review-configuration/LaneReviewers.tsx
index f1dcd53e7a..d6feada9dc 100644
--- a/src/bundled/review-configuration/LaneReviewers.tsx
+++ b/src/bundled/review-configuration/LaneReviewers.tsx
@@ -1,4 +1,5 @@
 import type { AgentChoicesSnapshot } from "../../features/agents/choices";
+import { Avatar } from "../../shared/design-system/ui/Avatar";
 import { Button } from "../../shared/design-system/ui/Button";
 import { Select } from "../../shared/design-system/ui/Select";
 
@@ -22,7 +23,7 @@ export function LaneReviewers({
   return (
     <div className="review-config-reviewers">
       <Select
-        label={`Lane ${lane} reviewers`}
+        label="Agents"
         variant="field"
         value=""
         placeholder="Add reviewer…"
@@ -33,6 +34,15 @@ export function LaneReviewers({
             options: available.map((agent) => ({
               value: agent.pubkey,
               label: `${agent.managedName ?? agent.name} (${agent.pubkey.slice(0, 8)})`,
+              leading: (
+                <Avatar
+                  src={agent.avatar}
+                  alt=""
+                  fallback={agent.managedName ?? agent.name}
+                  shape="squircle"
+                  size="tiny"
+                />
+              ),
             })),
           },
         ]}
@@ -50,7 +60,14 @@ export function LaneReviewers({
           (item) => item.pubkey === pubkey,
         );
         return (
-          <div key={pubkey} className="review-config-actions">
+          <div key={pubkey} className="review-config-agent-row">
+            <Avatar
+              src={agent?.avatar}
+              alt={`${name} avatar`}
+              fallback={name}
+              shape="squircle"
+              size="small"
+            />
             <span title={pubkey}>
               {name}
               {!selectable ? " — unavailable in this session" : ""}
@@ -70,3 +87,26 @@ export function LaneReviewers({
     </div>
   );
 }
+
+export function ReviewerIdentity({
+  pubkey,
+  choices,
+}: {
+  pubkey: string;
+  choices: AgentChoicesSnapshot;
+}) {
+  const agent = choices.identities.find((item) => item.pubkey === pubkey);
+  const name = agent?.managedName ?? agent?.name ?? pubkey;
+  return (
+    <div className="review-config-agent-row">
+      <Avatar
+        src={agent?.avatar}
+        alt={`${name} avatar`}
+        fallback={name}
+        shape="squircle"
+        size="small"
+      />
+      <span title={pubkey}>{name}</span>
+    </div>
+  );
+}
diff --git a/src/bundled/review-configuration/LaneRules.tsx b/src/bundled/review-configuration/LaneRules.tsx
index 4755824e36..dd8b333eaa 100644
--- a/src/bundled/review-configuration/LaneRules.tsx
+++ b/src/bundled/review-configuration/LaneRules.tsx
@@ -1,3 +1,5 @@
+import { SettingsGroup } from "../../shared/design-system/ui/SettingsGroup";
+import { InlineHeader } from "../../shared/design-system/ui/Header";
 import { Button } from "../../shared/design-system/ui/Button";
 import { Field } from "../../shared/design-system/ui/Field";
 import { Input } from "../../shared/design-system/ui/Input";
@@ -28,12 +30,15 @@ export function LaneRules({
     });
   return (
     <>
+      <InlineHeader
+        title="Routing rules"
+        subtitle="At least one rule is required. A PR can match several lanes."
+      />
       <Select
-        label={`Lane ${lane} routing`}
+        label="Match"
         variant="field"
         disabled={disabled}
         value={routing.mode}
-        description="No rules matches every PR. A PR can match several lanes."
         groups={[
           {
             label: "Match",
@@ -47,76 +52,91 @@ export function LaneRules({
           onChange({ ...routing, mode: mode as LaneRouting["mode"] })
         }
       />
-      {routing.rules.map((rule, index) => (
-        <div className="review-config-rule" key={rule.id}>
-          <Select
-            label={`Lane ${lane} rule ${index + 1} field`}
-            variant="field"
-            disabled={disabled}
-            value={rule.field}
-            groups={[{ label: "PR field", options: [...ruleFields] }]}
-            onValueChange={(raw) => {
-              const field = raw as LaneRule["field"];
-              update(index, {
-                id: rule.id,
-                field,
-                operator: ruleOperators[field][0].value,
-                value: "",
-              });
-            }}
-          />
-          <Select
-            label={`Lane ${lane} rule ${index + 1} comparison`}
-            variant="field"
-            disabled={disabled}
-            value={rule.operator}
-            groups={[
-              { label: "Comparison", options: [...ruleOperators[rule.field]] },
-            ]}
-            onValueChange={(operator) =>
-              update(index, {
-                ...rule,
-                operator: operator as LaneRule["operator"],
-              })
-            }
-          />
-          <Field
-            label={`Lane ${lane} rule ${index + 1} value`}
-            description={
-              rule.field === "path"
-                ? "Case-sensitive paths: src/**, **/*.tsx. * matches within a directory; ** matches directories. Renames use the new path."
-                : rule.field === "label"
-                  ? "Exact label name, ignoring case."
-                  : rule.field === "title"
-                    ? "Text to find in the title, ignoring case."
-                    : "Whole number, including zero."
-            }
+      <SettingsGroup layout="cards">
+        {routing.rules.map((rule, index) => (
+          <section
+            className="review-config-rule-card"
+            aria-label={`Rule ${index + 1}`}
+            key={rule.id}
           >
-            <Input
-              required
-              maxLength={200}
-              disabled={disabled}
-              value={rule.value}
-              inputMode={rule.field === "files" ? "numeric" : "text"}
-              onValueChange={(text) => update(index, { ...rule, value: text })}
-            />
-          </Field>
-          <div>
-            <Button
-              disabled={disabled}
-              aria-label={`Remove rule ${index + 1} from lane ${lane}`}
-              onClick={() =>
-                onChange({
-                  ...routing,
-                  rules: routing.rules.filter((_, i) => i !== index),
-                })
-              }
-            >
-              Remove
-            </Button>
-          </div>
-        </div>
-      ))}
+            <div className="review-config-rule-heading">
+              <span className="text-body-sm">Rule {index + 1}</span>
+              <Button
+                size="sm"
+                disabled={disabled || routing.rules.length === 1}
+                aria-label={`Remove rule ${index + 1} from lane ${lane}`}
+                onClick={() =>
+                  onChange({
+                    ...routing,
+                    rules: routing.rules.filter((_, i) => i !== index),
+                  })
+                }
+              >
+                Remove
+              </Button>
+            </div>
+            <div className="review-config-rule">
+              <Select
+                label="Field"
+                variant="field"
+                disabled={disabled}
+                value={rule.field}
+                groups={[{ label: "PR field", options: [...ruleFields] }]}
+                onValueChange={(raw) => {
+                  const field = raw as LaneRule["field"];
+                  update(index, {
+                    id: rule.id,
+                    field,
+                    operator: ruleOperators[field][0].value,
+                    value: "",
+                  });
+                }}
+              />
+              <Select
+                label="Comparison"
+                variant="field"
+                disabled={disabled}
+                value={rule.operator}
+                groups={[
+                  {
+                    label: "Comparison",
+                    options: [...ruleOperators[rule.field]],
+                  },
+                ]}
+                onValueChange={(operator) =>
+                  update(index, {
+                    ...rule,
+                    operator: operator as LaneRule["operator"],
+                  })
+                }
+              />
+              <Field
+                label="Value"
+                description={
+                  rule.field === "path"
+                    ? "Case-sensitive paths: src/**, **/*.tsx. * matches within a directory; ** matches directories. Renames use the new path."
+                    : rule.field === "label"
+                      ? "Exact label name, ignoring case."
+                      : rule.field === "title"
+                        ? "Text to find in the title, ignoring case."
+                        : "Whole number, including zero."
+                }
+              >
+                <Input
+                  required
+                  maxLength={200}
+                  disabled={disabled}
+                  value={rule.value}
+                  inputMode={rule.field === "files" ? "numeric" : "text"}
+                  onValueChange={(text) =>
+                    update(index, { ...rule, value: text })
+                  }
+                />
+              </Field>
+            </div>
+          </section>
+        ))}
+      </SettingsGroup>
       <div>
         <Button
           disabled={disabled || routing.rules.length >= 12}
@@ -135,9 +155,13 @@ export function LaneRules({
             })
           }
         >
-          Add rule to lane {lane}
+          Add rule
         </Button>
       </div>
     </>
   );
 }
+
+export function ruleDescription(rule: LaneRule) {
+  return `${ruleFields.find((field) => field.value === rule.field)?.label} ${ruleOperators[rule.field].find((operator) => operator.value === rule.operator)?.label} “${rule.value}”`;
+}
diff --git a/src/bundled/review-configuration/README.md b/src/bundled/review-configuration/README.md
index 3879953496..a39bb9aed3 100644
--- a/src/bundled/review-configuration/README.md
+++ b/src/bundled/review-configuration/README.md
@@ -5,7 +5,9 @@ settings. Enable **Review Configuration** in Settings → Plugins → Manage plu
 Choose a channel, register a GitHub repository, add named lanes, reviewer agents, and instructions,
 and save. Open a repository row to work with one repository at a time. Its **Configuration**
 section contains lane settings; **Pull requests** contains Submit PR and Existing PRs.
-Lane editors and routing rules expand on demand. Cancel or save a draft before
+Saved lane cards show their agents, instructions, and rules. **Edit lane** opens one lane;
+**Save lane** persists it before another can be added with the bottom **Add lane** button.
+**Back to lanes** cancels the editor; **Back to repositories** returns to the list. Cancel or save a draft before
 switching sections or repositories. These are local page sections: reload returns
 to the repository list; they do not create separate shell tabs or history visits. The page
 remembers your channel per identity/community and selects it automatically when
@@ -28,7 +30,7 @@ or reviewing. No model process or reminder timer is started by this plugin.
 
 Enable this plugin in **Settings → Plugins → Manage plugins**, then open its
 sidebar entry. Choose a channel and register a repository. For each lane, select
-reviewer agents and enter instructions, then save. Open its Configuration section to edit settings.
+reviewer agents, enter instructions, and configure at least one routing rule, then save. Open its Configuration section to edit settings.
 These selections do not start reviews or grant agents access to the channel.
 
 ---
@@ -135,8 +137,8 @@ synchronization, and new review rounds remain future work.
 
 ## Routing rules
 
-Each lane accepts up to 12 rules, combined with **Match all rules** or **Match any
-rule**. No rules matches every PR. A PR can match several lanes; zero matches
+New or edited lanes require 1–12 rules, combined with **Match all rules** or **Match any
+rule**. Earlier rule-free lanes remain readable and match every PR until edited; editing one requires adding a rule. A PR can match several lanes; zero matches
 prevents submission. Title contains/does-not-contain and exact label matching
 ignore case. File counts support inclusive minimum and maximum values. Paths are
 case-sensitive and relative to the repository: `*` and `?` match within a path
diff --git a/src/bundled/review-configuration/ReviewConfigurationPage.test.tsx b/src/bundled/review-configuration/ReviewConfigurationPage.test.tsx
index ec9ca36904..20947f9adf 100644
--- a/src/bundled/review-configuration/ReviewConfigurationPage.test.tsx
+++ b/src/bundled/review-configuration/ReviewConfigurationPage.test.tsx
@@ -25,7 +25,12 @@ function fixture() {
   };
   const listeners = new Set<() => void>();
   const agents = [
-    { pubkey: "a".repeat(64), name: "Backend reviewer", managed: true },
+    {
+      pubkey: "a".repeat(64),
+      name: "Backend reviewer",
+      managed: true,
+      avatar: "https://example.org/agent.png",
+    },
     { pubkey: "b".repeat(64), name: "UI reviewer", managed: true },
   ];
   let choices = {
@@ -131,12 +136,11 @@ async function openDraft() {
     screen.getByRole("textbox", { name: "GitHub repository" }),
     "example-org/project",
   );
-  if (!screen.queryByRole("textbox", { name: "Lane 1 instructions" }))
-    await user.click(screen.getByRole("button", { name: /^General/ }));
   await user.type(
-    screen.getByRole("textbox", { name: "Lane 1 instructions" }),
+    screen.getByRole("textbox", { name: "Instructions" }),
     "Check authorization and keyboard navigation.",
   );
+  await user.type(screen.getByRole("textbox", { name: "Value" }), "review");
   return user;
 }
 
@@ -144,34 +148,24 @@ it("registers, reloads and edits a repository through the real form and artifact
   const test = fixture();
   render(<ReviewConfigurationCommunity session={test.session} />);
   const user = await openDraft();
-  await user.click(screen.getByRole("button", { name: "Save settings" }));
+  await user.click(screen.getByRole("button", { name: "Save lane" }));
   await screen.findByText("Saved example-org/project.");
   await user.click(screen.getByRole("button", { name: "Reload" }));
-  await screen.findByRole("button", { name: "Edit example-org/project" });
-  await user.click(
-    screen.getByRole("button", { name: "Edit example-org/project" }),
-  );
-  if (!screen.queryByRole("textbox", { name: "Lane 1 instructions" }))
-    await userEvent
-      .setup()
-      .click(screen.getByRole("button", { name: /^General/ }));
+  await screen.findByRole("button", { name: "Edit General lane" });
+  await user.click(screen.getByRole("button", { name: "Edit General lane" }));
   expect(
     (
       screen.getByRole("textbox", {
-        name: "Lane 1 instructions",
+        name: "Instructions",
       }) as HTMLTextAreaElement
     ).value,
   ).toBe("Check authorization and keyboard navigation.");
-  await user.clear(
-    screen.getByRole("textbox", { name: "Lane 1 instructions" }),
-  );
-  if (!screen.queryByRole("textbox", { name: "Lane 1 instructions" }))
-    await user.click(screen.getByRole("button", { name: /^General/ }));
+  await user.clear(screen.getByRole("textbox", { name: "Instructions" }));
   await user.type(
-    screen.getByRole("textbox", { name: "Lane 1 instructions" }),
+    screen.getByRole("textbox", { name: "Instructions" }),
     "Check database migrations.",
   );
-  await user.click(screen.getByRole("button", { name: "Save settings" }));
+  await user.click(screen.getByRole("button", { name: "Save lane" }));
   await screen.findByText("Saved example-org/project.");
   expect(test.publish).toHaveBeenCalledTimes(2);
   expect(test.publish.mock.calls[1]?.[0].tags).toContainEqual([
@@ -191,7 +185,7 @@ it("keeps the draft on rejection, prevents duplicate submissions, and recovers",
   );
   render(<ReviewConfigurationCommunity session={test.session} />);
   const user = await openDraft();
-  await user.dblClick(screen.getByRole("button", { name: "Save settings" }));
+  await user.dblClick(screen.getByRole("button", { name: "Save lane" }));
   await waitFor(() => expect(test.publish).toHaveBeenCalledTimes(1));
   expect(
     (screen.getByRole("button", { name: "Cancel" }) as HTMLButtonElement)
@@ -201,18 +195,14 @@ it("keeps the draft on rejection, prevents duplicate submissions, and recovers",
   expect((await screen.findByRole("alert")).textContent).toContain(
     "Your draft is still here",
   );
-  if (!screen.queryByRole("textbox", { name: "Lane 1 instructions" }))
-    await userEvent
-      .setup()
-      .click(screen.getByRole("button", { name: /^General/ }));
   expect(
     (
       screen.getByRole("textbox", {
-        name: "Lane 1 instructions",
+        name: "Instructions",
       }) as HTMLTextAreaElement
     ).value,
   ).toContain("keyboard navigation");
-  await user.click(screen.getByRole("button", { name: "Save settings" }));
+  await user.click(screen.getByRole("button", { name: "Save lane" }));
   await screen.findByText("Saved example-org/project.");
 });
 
@@ -222,33 +212,25 @@ it("preserves the draft while channel authorization reconfirms, but gates Save",
   await openDraft();
   act(() => test.metadataCached(true));
   expect(
-    (screen.getByRole("button", { name: "Save settings" }) as HTMLButtonElement)
+    (screen.getByRole("button", { name: "Save lane" }) as HTMLButtonElement)
       .disabled,
   ).toBe(true);
-  if (!screen.queryByRole("textbox", { name: "Lane 1 instructions" }))
-    await userEvent
-      .setup()
-      .click(screen.getByRole("button", { name: /^General/ }));
   expect(
     (
       screen.getByRole("textbox", {
-        name: "Lane 1 instructions",
+        name: "Instructions",
       }) as HTMLTextAreaElement
     ).value,
   ).toContain("keyboard navigation");
   act(() => test.metadataCached(false));
   expect(
-    (screen.getByRole("button", { name: "Save settings" }) as HTMLButtonElement)
+    (screen.getByRole("button", { name: "Save lane" }) as HTMLButtonElement)
       .disabled,
   ).toBe(false);
-  if (!screen.queryByRole("textbox", { name: "Lane 1 instructions" }))
-    await userEvent
-      .setup()
-      .click(screen.getByRole("button", { name: /^General/ }));
   expect(
     (
       screen.getByRole("textbox", {
-        name: "Lane 1 instructions",
+        name: "Instructions",
       }) as HTMLTextAreaElement
     ).value,
   ).toContain("keyboard navigation");
@@ -269,7 +251,7 @@ it("aborts an unfinished write when the page leaves its session", async () => {
   } as RelaySession;
   const view = render(<ReviewConfigurationCommunity session={session} />);
   const user = await openDraft();
-  await user.click(screen.getByRole("button", { name: "Save settings" }));
+  await user.click(screen.getByRole("button", { name: "Save lane" }));
   await waitFor(() => expect(publish).toHaveBeenCalledTimes(1));
   view.unmount();
   expect(publish.mock.calls[0]?.[1].aborted).toBe(true);
@@ -301,15 +283,16 @@ it("counts unreadable records toward the limit when a new repository is saved",
     screen.getByRole("textbox", { name: "GitHub repository" }),
     "example-org/project",
   );
-  if (!screen.queryByRole("textbox", { name: "Lane 1 instructions" }))
-    await user.click(screen.getByRole("button", { name: /^General/ }));
   await user.type(
-    screen.getByRole("textbox", { name: "Lane 1 instructions" }),
+    screen.getByRole("textbox", { name: "Instructions" }),
     "Check tests.",
   );
-  await user.click(screen.getByRole("button", { name: "Save settings" }));
+  await user.type(screen.getByRole("textbox", { name: "Value" }), "review");
+  await user.click(screen.getByRole("button", { name: "Save lane" }));
   await screen.findByText("Saved example-org/project.");
-  await user.click(screen.getByRole("button", { name: "All repositories" }));
+  await user.click(
+    screen.getByRole("button", { name: "Back to repositories" }),
+  );
   expect(
     (
       screen.getByRole("button", {
@@ -323,15 +306,15 @@ it("saves multiple lane reviewers, reloads their identities, and preserves unava
   const test = fixture();
   render(<ReviewConfigurationCommunity session={test.session} />);
   const user = await openDraft();
-  await user.click(screen.getByRole("combobox", { name: "Lane 1 reviewers" }));
+  await user.click(screen.getByRole("combobox", { name: "Agents" }));
   await user.click(
     await screen.findByRole("option", { name: "Backend reviewer (aaaaaaaa)" }),
   );
-  await user.click(screen.getByRole("combobox", { name: "Lane 1 reviewers" }));
+  await user.click(screen.getByRole("combobox", { name: "Agents" }));
   await user.click(
     await screen.findByRole("option", { name: "UI reviewer (bbbbbbbb)" }),
   );
-  await user.click(screen.getByRole("button", { name: "Save settings" }));
+  await user.click(screen.getByRole("button", { name: "Save lane" }));
   await screen.findByText("Saved example-org/project.");
   const content = test.publish.mock.calls[0]?.[0].content;
   expect(JSON.parse(content ?? "{}").lanes[0].reviewers).toEqual([
@@ -340,9 +323,8 @@ it("saves multiple lane reviewers, reloads their identities, and preserves unava
   ]);
   await user.click(screen.getByRole("button", { name: "Reload" }));
   await user.click(
-    await screen.findByRole("button", { name: "Edit example-org/project" }),
+    await screen.findByRole("button", { name: "Edit General lane" }),
   );
-  await user.click(screen.getByRole("button", { name: /^General/ }));
   await screen.findByRole("button", {
     name: "Remove Backend reviewer from lane 1",
   });
@@ -351,7 +333,7 @@ it("saves multiple lane reviewers, reloads their identities, and preserves unava
   await user.click(
     screen.getByRole("button", { name: "Remove Backend reviewer from lane 1" }),
   );
-  await user.click(screen.getByRole("button", { name: "Save settings" }));
+  await user.click(screen.getByRole("button", { name: "Save lane" }));
   await screen.findByText("Saved example-org/project.");
   expect(
     JSON.parse(test.publish.mock.calls[1]?.[0].content ?? "{}").lanes[0]
@@ -368,11 +350,11 @@ it("refreshes failed agent and archive reads without discarding the draft", asyn
   expect(screen.getByText(/Archive read failed/)).toBeTruthy();
   await user.click(screen.getByRole("button", { name: "Refresh agents" }));
   expect(test.session.agentChoices.refresh).toHaveBeenCalledWith(true);
-  await user.click(screen.getByRole("combobox", { name: "Lane 1 reviewers" }));
+  await user.click(screen.getByRole("combobox", { name: "Agents" }));
   await user.click(
     await screen.findByRole("option", { name: "Backend reviewer (aaaaaaaa)" }),
   );
-  await user.click(screen.getByRole("button", { name: "Save settings" }));
+  await user.click(screen.getByRole("button", { name: "Save lane" }));
   await screen.findByText("Saved example-org/project.");
   expect(
     JSON.parse(test.publish.mock.calls[0]?.[0].content ?? "null").lanes[0]
@@ -431,19 +413,15 @@ it("saves path rules through field changes and preserves them after reload", asy
   const test = fixture();
   render(<ReviewConfigurationCommunity session={test.session} />);
   const user = await openDraft();
-  await user.click(screen.getByRole("button", { name: /^Routing rules/ }));
-  await user.click(screen.getByRole("button", { name: "Add rule to lane 1" }));
-  await user.click(
-    screen.getByRole("combobox", { name: "Lane 1 rule 1 field" }),
-  );
+  await user.click(screen.getByRole("combobox", { name: "Field" }));
   await user.click(
     await screen.findByRole("option", { name: "Changed file path" }),
   );
   await user.type(
-    screen.getByRole("textbox", { name: "Lane 1 rule 1 value" }),
+    screen.getByRole("textbox", { name: "Value" }),
     "src/**/*.tsx",
   );
-  await user.click(screen.getByRole("button", { name: "Save settings" }));
+  await user.click(screen.getByRole("button", { name: "Save lane" }));
   await screen.findByText("Saved example-org/project.");
   const saved = JSON.parse(test.publish.mock.calls[0]?.[0].content ?? "{}")
     .lanes[0].routing;
@@ -455,26 +433,23 @@ it("saves path rules through field changes and preserves them after reload", asy
   });
   await user.click(screen.getByRole("button", { name: "Reload" }));
   await user.click(
-    await screen.findByRole("button", { name: "Edit example-org/project" }),
+    await screen.findByRole("button", { name: "Edit General lane" }),
   );
-  await user.click(screen.getByRole("button", { name: /^General/ }));
-  await user.click(screen.getByRole("button", { name: /^Routing rules/ }));
   expect(
     (
       screen.getByRole("textbox", {
-        name: "Lane 1 rule 1 value",
+        name: "Value",
       }) as HTMLInputElement
     ).value,
   ).toBe("src/**/*.tsx");
-  await user.click(
-    screen.getByRole("button", { name: "Remove rule 1 from lane 1" }),
-  );
-  await user.click(screen.getByRole("button", { name: "Save settings" }));
-  await screen.findByText("Saved example-org/project.");
   expect(
-    JSON.parse(test.publish.mock.calls[1]?.[0].content ?? "{}").lanes[0].routing
-      .rules,
-  ).toEqual([]);
+    (
+      screen.getByRole("button", {
+        name: "Remove rule 1 from lane 1",
+      }) as HTMLButtonElement
+    ).disabled,
+  ).toBe(true);
+  expect(test.publish).toHaveBeenCalledTimes(1);
 });
 
 it("preserves the remembered channel until pending metadata finishes", async () => {
@@ -512,13 +487,13 @@ it("separates a repository's PR activity and guards drafts before switching view
   const test = fixture();
   render(<ReviewConfigurationCommunity session={test.session} />);
   const user = await openDraft();
-  await user.click(screen.getByRole("button", { name: "Save settings" }));
+  await user.click(screen.getByRole("button", { name: "Save lane" }));
   await screen.findByText("Saved example-org/project.");
   expect(screen.queryByRole("region", { name: "PR submissions" })).toBeNull();
   await user.click(screen.getByRole("tab", { name: "Pull requests" }));
   await screen.findByRole("button", { name: "Submit PR" });
   expect(
-    screen.queryByRole("button", { name: "Edit example-org/project" }),
+    screen.queryByRole("button", { name: "Edit General lane" }),
   ).toBeNull();
   await user.click(screen.getByRole("button", { name: "Submit PR" }));
   expect(
@@ -532,35 +507,32 @@ it("separates a repository's PR activity and guards drafts before switching view
   expect(
     (
       screen.getByRole("button", {
-        name: "All repositories",
+        name: "Back to repositories",
       }) as HTMLButtonElement
     ).disabled,
   ).toBe(true);
   await user.click(screen.getByRole("button", { name: "Cancel" }));
   await user.click(screen.getByRole("tab", { name: "Configuration" }));
-  await user.click(
-    screen.getByRole("button", { name: "Edit example-org/project" }),
-  );
+  await user.click(screen.getByRole("button", { name: "Edit General lane" }));
   expect(
     screen
       .getByRole("tab", { name: "Pull requests" })
       .getAttribute("aria-disabled"),
   ).toBe("true");
-  await user.click(screen.getByRole("button", { name: /^General/ }));
-  const field = screen.getByRole("textbox", { name: "Lane 1 instructions" });
+  const field = screen.getByRole("textbox", { name: "Instructions" });
   await user.clear(field);
   await user.type(field, "Preserve collapsed drafts");
-  await user.click(screen.getByRole("button", { name: /^General/ }));
-  await user.click(screen.getByRole("button", { name: /^General/ }));
   expect(
     (
       screen.getByRole("textbox", {
-        name: "Lane 1 instructions",
+        name: "Instructions",
       }) as HTMLTextAreaElement
     ).value,
   ).toBe("Preserve collapsed drafts");
   await user.click(screen.getByRole("button", { name: "Cancel" }));
-  await user.click(screen.getByRole("button", { name: "All repositories" }));
+  await user.click(
+    screen.getByRole("button", { name: "Back to repositories" }),
+  );
   await user.click(
     screen.getByRole("button", { name: "Open example-org/project" }),
   );
@@ -575,7 +547,7 @@ it("blocks editor entry while a reload can replace the repository", async () =>
   const test = fixture();
   render(<ReviewConfigurationCommunity session={test.session} />);
   const user = await openDraft();
-  await user.click(screen.getByRole("button", { name: "Save settings" }));
+  await user.click(screen.getByRole("button", { name: "Save lane" }));
   await screen.findByText("Saved example-org/project.");
   let finish!: (events: EventData[]) => void;
   test.snapshotRead.mockImplementationOnce(
@@ -589,7 +561,7 @@ it("blocks editor entry while a reload can replace the repository", async () =>
     expect(
       (
         screen.getByRole("button", {
-          name: "Edit example-org/project",
+          name: "Edit General lane",
         }) as HTMLButtonElement
       ).disabled,
     ).toBe(true);
@@ -622,9 +594,11 @@ it("maps a pasted URL to its configured repository and keeps unknown URLs editab
     <ReviewConfigurationCommunity session={test.session} readPull={readPull} />,
   );
   const user = await openDraft();
-  await user.click(screen.getByRole("button", { name: "Save settings" }));
+  await user.click(screen.getByRole("button", { name: "Save lane" }));
   await screen.findByText("Saved example-org/project.");
-  await user.click(screen.getByRole("button", { name: "All repositories" }));
+  await user.click(
+    screen.getByRole("button", { name: "Back to repositories" }),
+  );
   await user.click(screen.getByRole("button", { name: "Submit PR" }));
   const input = screen.getByRole("textbox", { name: "GitHub PR URL" });
   await user.type(input, "https://github.com/example-org/unknown/pull/42");
@@ -656,3 +630,96 @@ it("maps a pasted URL to its configured repository and keeps unknown URLs editab
   await user.click(screen.getByRole("tab", { name: "Pull requests" }));
   expect(screen.queryByRole("textbox", { name: "Pull request" })).toBeNull();
 });
+
+it("requires a routing value and saves each lane before allowing another", async () => {
+  const test = fixture();
+  render(<ReviewConfigurationCommunity session={test.session} />);
+  const user = await openDraft();
+  const value = screen.getByRole("textbox", { name: "Value" });
+  await user.clear(value);
+  await user.click(screen.getByRole("button", { name: "Save lane" }));
+  expect((await screen.findByRole("alert")).textContent).toContain(
+    "Each routing rule needs",
+  );
+  expect(test.publish).not.toHaveBeenCalled();
+  expect(
+    (screen.getByRole("button", { name: "Add lane" }) as HTMLButtonElement)
+      .disabled,
+  ).toBe(true);
+  await user.type(value, "review");
+  await user.click(screen.getByRole("button", { name: "Save lane" }));
+  await screen.findByText("Saved example-org/project.");
+  await user.click(screen.getByRole("button", { name: "Add lane" }));
+  await user.type(
+    screen.getByRole("textbox", { name: "Lane name" }),
+    "Backend",
+  );
+  await user.type(
+    screen.getByRole("textbox", { name: "Instructions" }),
+    "Check quantity validation.",
+  );
+  await user.type(screen.getByRole("textbox", { name: "Value" }), "backend");
+  expect(
+    (screen.getByRole("button", { name: "Add lane" }) as HTMLButtonElement)
+      .disabled,
+  ).toBe(true);
+  await user.click(screen.getByRole("combobox", { name: "Agents" }));
+  await user.click(
+    await screen.findByRole("option", { name: "Backend reviewer (aaaaaaaa)" }),
+  );
+  expect(
+    screen.getByRole("img", { name: "Backend reviewer avatar" }),
+  ).toBeTruthy();
+  await user.click(screen.getByRole("button", { name: "Save lane" }));
+  await screen.findByRole("region", { name: "Backend lane" });
+  const saved = JSON.parse(test.publish.mock.calls[1]?.[0].content ?? "{}");
+  expect(saved.lanes.map((lane: { name: string }) => lane.name)).toEqual([
+    "General",
+    "Backend",
+  ]);
+  expect(test.publish.mock.calls[1]?.[0].tags).toContainEqual([
+    "prev",
+    test.publish.mock.calls[0]?.[0].id,
+  ]);
+  await user.click(screen.getByRole("button", { name: "Edit Backend lane" }));
+  expect(
+    (screen.getByRole("textbox", { name: "Value" }) as HTMLInputElement).value,
+  ).toBe("backend");
+  await user.click(screen.getByRole("button", { name: "Back to lanes" }));
+  expect(screen.getByRole("button", { name: "Edit Backend lane" })).toBe(
+    document.activeElement,
+  );
+  expect(test.publish).toHaveBeenCalledTimes(2);
+});
+
+it("returns focus to the lane region after removing the edited lane", async () => {
+  const test = fixture();
+  render(<ReviewConfigurationCommunity session={test.session} />);
+  const user = await openDraft();
+  await user.click(screen.getByRole("button", { name: "Save lane" }));
+  await screen.findByText("Saved example-org/project.");
+  await user.click(screen.getByRole("button", { name: "Add lane" }));
+  await user.type(screen.getByRole("textbox", { name: "Lane name" }), "Second");
+  await user.type(
+    screen.getByRole("textbox", { name: "Instructions" }),
+    "Review tests",
+  );
+  await user.type(screen.getByRole("textbox", { name: "Value" }), "tests");
+  await user.click(screen.getByRole("button", { name: "Save lane" }));
+  await user.click(
+    await screen.findByRole("button", { name: "Edit Second lane" }),
+  );
+  await user.click(screen.getByRole("button", { name: "Remove lane" }));
+  expect(test.publish).toHaveBeenCalledTimes(2);
+  await user.click(screen.getByRole("button", { name: "Confirm remove lane" }));
+  await waitFor(() =>
+    expect(
+      screen.getByRole("region", { name: "Repository configuration" }),
+    ).toBe(document.activeElement),
+  );
+  expect(
+    JSON.parse(test.publish.mock.calls[2]?.[0].content ?? "{}").lanes.map(
+      (lane: { name: string }) => lane.name,
+    ),
+  ).toEqual(["General"]);
+});
diff --git a/src/bundled/review-configuration/ReviewConfigurationPage.tsx b/src/bundled/review-configuration/ReviewConfigurationPage.tsx
index 4b2fb31d3e..f312aa198c 100644
--- a/src/bundled/review-configuration/ReviewConfigurationPage.tsx
+++ b/src/bundled/review-configuration/ReviewConfigurationPage.tsx
@@ -1,6 +1,6 @@
 import { createPullReader, type ReadPull } from "./pull-facts";
 const publicPullReader = createPullReader();
-import { LaneRules } from "./LaneRules";
+import { LaneRules, ruleDescription } from "./LaneRules";
 import {
   useCallback,
   useEffect,
@@ -13,12 +13,14 @@ import { ReviewSubmissions } from "./ReviewSubmissions";
 import { pullRepository } from "./submissions";
 import type { Navigation } from "../../features/navigation/controller";
 import { splitPartition } from "../../features/relay/partition";
-import { LaneReviewers } from "./LaneReviewers";
+import { LaneReviewers, ReviewerIdentity } from "./LaneReviewers";
 import { useChannelList, useRelayConnection } from "../../features/relay/react";
 import type { RelayData } from "../../features/relay/service";
 import type { RelaySession } from "../../features/relay/session";
-import { ListChecksIcon } from "../../shared/design-system/icons";
-import { Accordion } from "../../shared/design-system/ui/Accordion";
+import {
+  ArrowLeftIcon,
+  ListChecksIcon,
+} from "../../shared/design-system/icons";
 import { NavigationItem } from "../../shared/design-system/ui/NavigationItem";
 import { Tabs } from "../../shared/design-system/ui/Tabs";
 import { Button } from "../../shared/design-system/ui/Button";
@@ -38,6 +40,7 @@ import {
   repositoryName,
   saveConfiguration,
   type ReviewConfig,
+  type ReviewLane,
   type SavedReviewConfig,
 } from "./configuration";
 import "./review-configuration.css";
@@ -221,6 +224,8 @@ function ChannelConfiguration({
   onEditingChange: (editing: boolean) => void;
   onOpenThread?: ((channel: string, id: string) => Promise<void>) | undefined;
 }) {
+  const choices = useAgentChoices(session, true, true);
+  const [laneId, setLaneId] = useState<string>();
   const [submitting, setSubmitting] = useState(false);
   const [lookup, setLookup] = useState(false);
   const [pullUrl, setPullUrl] = useState("");
@@ -243,10 +248,16 @@ function ChannelConfiguration({
     "configuration",
   );
   const selected = rows.find((row) => row.config.repository === repository);
-  const editorTrigger = useRef<HTMLButtonElement | null>(null);
+  const editorTrigger = useRef<HTMLElement | null>(null);
+  const lanesRegion = useRef<HTMLElement | null>(null);
   useEffect(() => {
     onEditingChange(editor !== undefined || submitting || lookup);
-    if (editor === undefined) editorTrigger.current?.focus();
+    if (editor === undefined) {
+      const trigger = editorTrigger.current;
+      if (trigger?.isConnected && !trigger.matches(":disabled"))
+        trigger.focus();
+      else lanesRegion.current?.focus();
+    }
     return () => onEditingChange(false);
   }, [editor, submitting, lookup, onEditingChange]);
   // biome-ignore lint/correctness/useExhaustiveDependencies: Reload explicitly requests a fresh snapshot.
@@ -431,17 +442,19 @@ function ChannelConfiguration({
         </>
       ) : (
         <>
-          <div>
-            <Button
-              disabled={!!editor || submitting}
-              onClick={() => {
-                setRepository("");
-                setNotice("");
-              }}
-            >
-              All repositories
-            </Button>
-          </div>
+          {!editor && (
+            <div>
+              <Button
+                disabled={submitting}
+                onClick={() => {
+                  setRepository("");
+                  setNotice("");
+                }}
+              >
+                <ArrowLeftIcon /> Back to repositories
+              </Button>
+            </div>
+          )}
           {selected && (
             <>
               <InlineHeader title={selected.config.repository} />
@@ -467,6 +480,8 @@ function ChannelConfiguration({
                     <section
                       className="review-config-form"
                       aria-label="Repository configuration"
+                      ref={lanesRegion}
+                      tabIndex={-1}
                     >
                       {editor ? (
                         <ConfigurationEditor
@@ -475,63 +490,126 @@ function ChannelConfiguration({
                           channel={channel}
                           writable={writable}
                           previous={editor === "new" ? undefined : editor}
+                          laneId={laneId}
                           existing={rows}
                           onCancel={() => setEditor(undefined)}
                           onSaved={saved}
                         />
                       ) : (
                         <>
-                          <div className="review-config-actions">
+                          <InlineHeader
+                            title="Lanes"
+                            subtitle="Each lane has its own agents, instructions, and routing rules."
+                            actions={
+                              <Button
+                                disabled={loading}
+                                onClick={() => {
+                                  setNotice("");
+                                  setReload((value) => value + 1);
+                                }}
+                              >
+                                Reload
+                              </Button>
+                            }
+                          />
+                          {error && <p role="alert">{error}</p>}
+                          <SettingsGroup layout="cards">
+                            {selected.config.lanes.map((lane) => (
+                              <section
+                                key={lane.id}
+                                aria-label={`${lane.name} lane`}
+                                className="review-config-lane-card"
+                              >
+                                <InlineHeader
+                                  title={lane.name}
+                                  actions={
+                                    <Button
+                                      ref={(node) => {
+                                        if (laneId === lane.id)
+                                          editorTrigger.current = node;
+                                      }}
+                                      disabled={!writable || loading || !!error}
+                                      aria-label={`Edit ${lane.name} lane`}
+                                      onClick={() => {
+                                        setLaneId(lane.id);
+                                        setNotice("");
+                                        setEditor(selected);
+                                      }}
+                                    >
+                                      Edit lane
+                                    </Button>
+                                  }
+                                />
+                                <div className="review-config-reviewers">
+                                  <span className="text-caption text-subtle">
+                                    Agents
+                                  </span>
+                                  {lane.reviewers.length ? (
+                                    lane.reviewers.map((pubkey) => (
+                                      <ReviewerIdentity
+                                        key={pubkey}
+                                        pubkey={pubkey}
+                                        choices={choices}
+                                      />
+                                    ))
+                                  ) : (
+                                    <p>No agents assigned.</p>
+                                  )}
+                                </div>
+                                <div className="review-config-summary-section">
+                                  <span className="text-caption text-subtle">
+                                    Routing rules ·{" "}
+                                    {lane.routing?.mode === "any"
+                                      ? "Match any"
+                                      : "Match all"}
+                                  </span>
+                                  {lane.routing?.rules.length ? (
+                                    <ul>
+                                      {lane.routing.rules.map((rule) => (
+                                        <li key={rule.id}>
+                                          {ruleDescription(rule)}
+                                        </li>
+                                      ))}
+                                    </ul>
+                                  ) : (
+                                    <p>
+                                      All PRs · Add a routing rule when editing
+                                      this lane.
+                                    </p>
+                                  )}
+                                </div>
+                                <div className="review-config-summary-section">
+                                  <span className="text-caption text-subtle">
+                                    Instructions
+                                  </span>
+                                  <p className="review-config-instructions">
+                                    {lane.instructions}
+                                  </p>
+                                </div>
+                              </section>
+                            ))}
+                          </SettingsGroup>
+                          <div>
                             <Button
-                              ref={editorTrigger}
-                              variant="prominent"
-                              disabled={!writable || loading || !!error}
-                              aria-label={`Edit ${selected.config.repository}`}
-                              onClick={(event) => {
-                                editorTrigger.current = event.currentTarget;
-                                setNotice("");
-                                setEditor(selected);
+                              ref={(node) => {
+                                if (!laneId) editorTrigger.current = node;
                               }}
-                            >
-                              Edit configuration
-                            </Button>
-                            <Button
-                              disabled={loading}
+                              variant="prominent"
+                              disabled={
+                                !writable ||
+                                loading ||
+                                !!error ||
+                                selected.config.lanes.length >= 12
+                              }
                               onClick={() => {
+                                setLaneId(undefined);
                                 setNotice("");
-                                setReload((value) => value + 1);
+                                setEditor(selected);
                               }}
                             >
-                              Reload
+                              Add lane
                             </Button>
                           </div>
-                          {error && <p role="alert">{error}</p>}
-                          <Accordion
-                            variant="form"
-                            items={selected.config.lanes.map((lane) => ({
-                              value: lane.id,
-                              title: (
-                                <span className="review-config-pr-summary">
-                                  <span>{lane.name}</span>
-                                  <span className="text-caption text-subtle">
-                                    {lane.reviewers.length}{" "}
-                                    {lane.reviewers.length === 1
-                                      ? "reviewer"
-                                      : "reviewers"}{" "}
-                                    ·{" "}
-                                    {lane.routing?.rules.length
-                                      ? `${lane.routing.rules.length} routing rules`
-                                      : "All PRs"}
-                                  </span>
-                                </span>
-                              ),
-                              content: (
-                                <p className="review-config-instructions">
-                                  {lane.instructions}
-                                </p>
-                              ),
-                            }))}
-                          />
                         </>
                       )}
                     </section>
@@ -575,6 +653,7 @@ function ConfigurationEditor({
   channel,
   writable,
   previous,
+  laneId,
   existing,
   onCancel,
   onSaved,
@@ -583,6 +662,7 @@ function ConfigurationEditor({
   channel: string;
   writable: boolean;
   previous: SavedReviewConfig | undefined;
+  laneId?: string | undefined;
   existing: readonly SavedReviewConfig[];
   onCancel: () => void;
   onSaved: (saved: SavedReviewConfig) => void;
@@ -590,32 +670,41 @@ function ConfigurationEditor({
   const choices = useAgentChoices(session, true, true);
   const [refreshingAgents, setRefreshingAgents] = useState(false);
   const [agentRefreshError, setAgentRefreshError] = useState("");
-  const [draft, setDraft] = useState<ReviewConfig>(
-    () =>
-      previous?.config ?? {
-        version: 1,
-        repository: "",
-        reminderMinutes: 15,
-        lanes: [
-          {
-            id: crypto.randomUUID(),
-            name: "General",
-            instructions: "",
-            reviewers: [],
-          },
-        ],
-      },
+  const original = previous?.config.lanes.find((lane) => lane.id === laneId);
+  const [repository, setRepository] = useState(
+    previous?.config.repository ?? "",
   );
-  const editorRegion = useRef<HTMLFormElement>(null);
-  useEffect(() => {
-    if (previous) editorRegion.current?.focus();
-  }, [previous]);
-  const [expanded, setExpanded] = useState<string[]>([]);
+  const [lane, setLane] = useState<ReviewLane>(() => ({
+    ...(original ?? {
+      id: crypto.randomUUID(),
+      name: previous ? "" : "General",
+      instructions: "",
+      reviewers: [],
+    }),
+    routing: original?.routing?.rules.length
+      ? original.routing
+      : {
+          mode: "all",
+          rules: [
+            {
+              id: crypto.randomUUID(),
+              field: "title",
+              operator: "contains",
+              value: "",
+            },
+          ],
+        },
+  }));
   const [busy, setBusy] = useState(false);
+  const [removing, setRemoving] = useState(false);
   const [error, setError] = useState("");
+  const editorRegion = useRef<HTMLFormElement>(null);
+  useEffect(() => {
+    editorRegion.current?.focus();
+  }, []);
   const operation = useRef<AbortController | undefined>(undefined);
   useEffect(() => () => operation.current?.abort(), []);
-  async function save() {
+  async function save(remove = false) {
     if (operation.current || !writable) return;
     const controller = new AbortController();
     operation.current = controller;
@@ -625,12 +714,27 @@ function ConfigurationEditor({
       if (
         !previous &&
         existing.some(
-          (row) => row.config.repository === repositoryName(draft.repository),
+          (row) => row.config.repository === repositoryName(repository),
         )
       )
         throw new Error(
           "This repository is already configured in this channel. Cancel and edit its saved settings.",
         );
+      if (!remove && !lane.routing?.rules.length)
+        throw new Error(
+          "Add at least one routing rule before saving this lane.",
+        );
+      const lanes = previous?.config.lanes ?? [];
+      const draft: ReviewConfig = {
+        version: 1,
+        reminderMinutes: 15,
+        repository,
+        lanes: remove
+          ? lanes.filter((item) => item.id !== lane.id)
+          : original
+            ? lanes.map((item) => (item.id === lane.id ? lane : item))
+            : [...lanes, lane],
+      };
       const result = await saveConfiguration(
         session,
         channel,
@@ -640,12 +744,10 @@ function ConfigurationEditor({
       );
       if (!controller.signal.aborted) onSaved(result);
     } catch (reason) {
-      if (!controller.signal.aborted) {
-        setExpanded(draft.lanes.map((lane) => lane.id));
+      if (!controller.signal.aborted)
         setError(
-          `${reason instanceof Error ? reason.message : "Could not save settings."} Your draft is still here. If settings changed elsewhere or the save timed out, copy your changes, then Cancel and Reload before retrying.`,
+          `${reason instanceof Error ? reason.message : "Could not save lane."} Your draft is still here. If settings changed elsewhere or the save timed out, copy your changes, then Cancel and Reload before retrying.`,
         );
-      }
     } finally {
       operation.current = undefined;
       if (!controller.signal.aborted) setBusy(false);
@@ -655,15 +757,30 @@ function ConfigurationEditor({
     <form
       ref={editorRegion}
       tabIndex={-1}
-      aria-label="Edit repository settings"
+      aria-label="Edit lane"
       noValidate
+      className="review-config-form"
       onSubmit={(event) => {
         event.preventDefault();
         void save();
       }}
-      className="review-config-form"
     >
-      {!previous && <InlineHeader title="Register repository" />}
+      <div>
+        <Button disabled={busy} onClick={onCancel}>
+          <ArrowLeftIcon />{" "}
+          {previous ? "Back to lanes" : "Back to repositories"}
+        </Button>
+      </div>
+      <InlineHeader
+        title={
+          original
+            ? `Edit ${original.name}`
+            : previous
+              ? "Add lane"
+              : "Register repository"
+        }
+        subtitle="Save this lane before adding another."
+      />
       {!previous && (
         <SettingsGroup layout="form">
           <Field
@@ -671,215 +788,143 @@ function ConfigurationEditor({
             description="Use owner/repository or the full repository URL."
           >
             <Input
-              autoFocus
               required
-              value={draft.repository}
-              readOnly={!!previous}
+              value={repository}
               disabled={busy}
               maxLength={250}
               placeholder="example-org/project"
-              onValueChange={(repository) => setDraft({ ...draft, repository })}
+              onValueChange={setRepository}
             />
           </Field>
         </SettingsGroup>
       )}
-      {choices.pending && <p role="status">Loading reviewer agents…</p>}
-      {!choices.pending && !choices.selectable.length && (
-        <p>
-          No reviewer agents are available in this session. Create or connect an
-          agent in Agents, then refresh this list.
-        </p>
-      )}
-      {choices.error && (
-        <p role="alert">Some agents could not be loaded: {choices.error}</p>
-      )}
-      {choices.archives.error && (
-        <p role="alert">
-          Archived agents could not be checked: {choices.archives.error}
-        </p>
-      )}
-      {agentRefreshError && <p role="alert">{agentRefreshError}</p>}
-      <div>
-        <Button
-          disabled={busy || refreshingAgents}
-          loading={refreshingAgents}
-          onClick={async () => {
-            setRefreshingAgents(true);
-            setAgentRefreshError("");
-            try {
-              await session.agentChoices.refresh(true);
-            } catch (reason) {
-              setAgentRefreshError(
-                reason instanceof Error
-                  ? reason.message
-                  : "Could not refresh agents.",
-              );
-            } finally {
-              setRefreshingAgents(false);
-            }
-          }}
-        >
-          Refresh agents
-        </Button>
-      </div>
-      <Accordion
-        variant="form"
-        keepMounted
-        value={expanded}
-        onValueChange={setExpanded}
-        items={draft.lanes.map((lane, index) => ({
-          value: lane.id,
-          title: (
-            <span className="review-config-pr-summary">
-              <span>{lane.name || `Lane ${index + 1}`}</span>
-              <span className="text-caption text-subtle">
-                {lane.reviewers.length}{" "}
-                {lane.reviewers.length === 1 ? "reviewer" : "reviewers"} ·{" "}
-                {lane.routing?.rules.length
-                  ? `${lane.routing.rules.length} rules`
-                  : "All PRs"}
-              </span>
-            </span>
-          ),
-          content: (
-            <section className="review-config-lane">
-              <div className="review-config-actions">
-                <Button
-                  disabled={busy || draft.lanes.length === 1}
-                  onClick={() =>
-                    setDraft({
-                      ...draft,
-                      lanes: draft.lanes.filter((item) => item.id !== lane.id),
-                    })
-                  }
-                >
-                  Remove lane {index + 1}
-                </Button>
-              </div>
-              <SettingsGroup layout="form">
-                <Field label={`Lane ${index + 1} name`}>
-                  <Input
-                    required
-                    maxLength={80}
-                    disabled={busy}
-                    value={lane.name}
-                    onValueChange={(name) =>
-                      setDraft({
-                        ...draft,
-                        lanes: draft.lanes.map((item) =>
-                          item.id === lane.id ? { ...item, name } : item,
-                        ),
-                      })
-                    }
-                  />
-                </Field>
-                <LaneReviewers
-                  lane={index + 1}
-                  reviewers={lane.reviewers}
-                  choices={choices}
-                  disabled={busy}
-                  onChange={(reviewers) =>
-                    setDraft({
-                      ...draft,
-                      lanes: draft.lanes.map((item) =>
-                        item.id === lane.id ? { ...item, reviewers } : item,
-                      ),
-                    })
-                  }
-                />
-                <Field
-                  label={`Lane ${index + 1} instructions`}
-                  description="Save the instructions reviewers should receive for this lane."
-                >
-                  <Textarea
-                    required
-                    rows={3}
-                    maxLength={8000}
-                    disabled={busy}
-                    value={lane.instructions}
-                    onChange={(event) =>
-                      setDraft({
-                        ...draft,
-                        lanes: draft.lanes.map((item) =>
-                          item.id === lane.id
-                            ? { ...item, instructions: event.target.value }
-                            : item,
-                        ),
-                      })
-                    }
-                  />
-                </Field>
-              </SettingsGroup>
-              <Accordion
-                variant="form"
-                keepMounted
-                items={[
-                  {
-                    value: "routing",
-                    title: `Routing rules (${lane.routing?.rules.length ?? 0})`,
-                    content: (
-                      <div className="review-config-form">
-                        {" "}
-                        <LaneRules
-                          lane={index + 1}
-                          value={lane.routing}
-                          disabled={busy}
-                          onChange={(routing) =>
-                            setDraft({
-                              ...draft,
-                              lanes: draft.lanes.map((item) =>
-                                item.id === lane.id
-                                  ? { ...item, routing }
-                                  : item,
-                              ),
-                            })
-                          }
-                        />
-                      </div>
-                    ),
-                  },
-                ]}
-              />
-            </section>
-          ),
-        }))}
-      />
-      <div>
-        <Button
-          disabled={busy || draft.lanes.length >= 12}
-          onClick={() => {
-            const id = crypto.randomUUID();
-            setExpanded([id]);
-            setDraft({
-              ...draft,
-              lanes: [
-                ...draft.lanes,
-                {
-                  id,
-                  name: "",
-                  instructions: "",
-                  reviewers: [],
-                },
-              ],
-            });
-          }}
+      <SettingsGroup layout="form">
+        <Field label="Lane name">
+          <Input
+            required
+            maxLength={80}
+            disabled={busy}
+            value={lane.name}
+            onValueChange={(name) => setLane({ ...lane, name })}
+          />
+        </Field>
+        <LaneReviewers
+          lane={1}
+          reviewers={lane.reviewers}
+          choices={choices}
+          disabled={busy}
+          onChange={(reviewers) => setLane({ ...lane, reviewers })}
+        />
+        {choices.pending && <p role="status">Loading reviewer agents…</p>}
+        {!choices.pending && !choices.selectable.length && (
+          <p>
+            No reviewer agents are available. Create or connect an agent, then
+            refresh.
+          </p>
+        )}
+        {choices.error && (
+          <p role="alert">Some agents could not be loaded: {choices.error}</p>
+        )}
+        {choices.archives.error && (
+          <p role="alert">
+            Archived agents could not be checked: {choices.archives.error}
+          </p>
+        )}
+        {agentRefreshError && <p role="alert">{agentRefreshError}</p>}
+        <div>
+          <Button
+            disabled={busy || refreshingAgents}
+            loading={refreshingAgents}
+            onClick={async () => {
+              setRefreshingAgents(true);
+              setAgentRefreshError("");
+              try {
+                await session.agentChoices.refresh(true);
+              } catch (reason) {
+                setAgentRefreshError(
+                  reason instanceof Error
+                    ? reason.message
+                    : "Could not refresh agents.",
+                );
+              } finally {
+                setRefreshingAgents(false);
+              }
+            }}
+          >
+            Refresh agents
+          </Button>
+        </div>
+        <Field
+          label="Instructions"
+          description="What should the agents review in this lane?"
         >
-          Add lane
-        </Button>
-      </div>
+          <Textarea
+            required
+            rows={3}
+            maxLength={8000}
+            disabled={busy}
+            value={lane.instructions}
+            onChange={(event) =>
+              setLane({ ...lane, instructions: event.target.value })
+            }
+          />
+        </Field>
+        <section className="review-config-form" aria-label="Lane routing rules">
+          <LaneRules
+            lane={1}
+            value={lane.routing}
+            disabled={busy}
+            onChange={(routing) => setLane({ ...lane, routing })}
+          />
+        </section>
+      </SettingsGroup>
       {error && <p role="alert">{error}</p>}
-      <div className="review-config-actions">
-        <Button disabled={busy} onClick={onCancel}>
-          Cancel
-        </Button>
-        <Button
-          type="submit"
-          variant="prominent"
-          loading={busy}
-          disabled={!writable}
-        >
-          Save settings
-        </Button>
+      {removing ? (
+        <div className="review-config-form">
+          <p>
+            Remove {original?.name} and its routing rules? Existing review
+            threads are kept.
+          </p>
+          <div className="review-config-actions">
+            <Button disabled={busy} onClick={() => setRemoving(false)}>
+              Keep lane
+            </Button>
+            <Button
+              disabled={busy || !writable}
+              onClick={() => void save(true)}
+            >
+              Confirm remove lane
+            </Button>
+          </div>
+        </div>
+      ) : (
+        <div className="review-config-actions">
+          <Button disabled={busy} onClick={onCancel}>
+            Cancel
+          </Button>
+          <Button
+            type="submit"
+            variant="prominent"
+            loading={busy}
+            disabled={!writable}
+          >
+            Save lane
+          </Button>
+          {original && previous && previous.config.lanes.length > 1 && (
+            <Button
+              disabled={busy || !writable}
+              onClick={() => setRemoving(true)}
+            >
+              Remove lane
+            </Button>
+          )}
+        </div>
+      )}
+      <div>
+        <Button disabled>Add lane</Button>
+        <p className="text-caption text-subtle">
+          Save or cancel this lane first.
+        </p>
       </div>
     </form>
   );
diff --git a/src/bundled/review-configuration/configuration.test.ts b/src/bundled/review-configuration/configuration.test.ts
index caa19259f0..4406af6fff 100644
--- a/src/bundled/review-configuration/configuration.test.ts
+++ b/src/bundled/review-configuration/configuration.test.ts
@@ -24,10 +24,19 @@ const config: ReviewConfig = {
       name: "General",
       instructions: "Check authorization and tests.",
       reviewers: ["a".repeat(64)],
+      routing: {
+        mode: "all",
+        rules: [
+          { id: "rule", field: "files", operator: "at-least", value: "0" },
+        ],
+      },
     },
   ],
 };
 
+const firstLane = config.lanes[0];
+if (!firstLane) throw new Error("Missing lane fixture");
+
 function host() {
   const key = keypair();
   let events: EventData[] = [];
@@ -74,7 +83,7 @@ it("creates and reloads a signed configuration, then updates the loaded revision
     ...config,
     lanes: [
       {
-        ...{ id: "general", name: "General", instructions: "", reviewers: [] },
+        ...firstLane,
         instructions: "Check keyboard navigation.",
       },
     ],
@@ -248,3 +257,38 @@ it("validates reviewer identities and reads earlier drafts without reviewers", (
     }).lanes[0]?.reviewers,
   ).toEqual([]);
 });
+
+it("requires rules on new or edited lanes while keeping legacy configurations readable", async () => {
+  const test = host();
+  const legacy = {
+    ...config,
+    lanes: config.lanes.map(({ routing: _, ...lane }) => lane),
+  };
+  expect(validateConfig(legacy)).toEqual(legacy);
+  await expect(
+    saveConfiguration(test.session, channel, legacy, undefined, signal()),
+  ).rejects.toThrow("at least one routing rule");
+  expect(test.sign).not.toHaveBeenCalled();
+  const first = await saveConfiguration(
+    test.session,
+    channel,
+    config,
+    undefined,
+    signal(),
+  );
+  const previous = { ...first, config: legacy };
+  const added = {
+    ...legacy,
+    lanes: [...legacy.lanes, { ...firstLane, id: "second", name: "Second" }],
+  };
+  await expect(
+    saveConfiguration(test.session, channel, added, previous, signal()),
+  ).resolves.toMatchObject({ config: added });
+  const edited = {
+    ...legacy,
+    lanes: legacy.lanes.map((lane) => ({ ...lane, instructions: "Changed" })),
+  };
+  await expect(
+    saveConfiguration(test.session, channel, edited, previous, signal()),
+  ).rejects.toThrow("at least one routing rule");
+});
diff --git a/src/bundled/review-configuration/configuration.ts b/src/bundled/review-configuration/configuration.ts
index eebb24e522..0c17184e60 100644
--- a/src/bundled/review-configuration/configuration.ts
+++ b/src/bundled/review-configuration/configuration.ts
@@ -187,6 +187,18 @@ export async function saveConfiguration(
   if (!writer)
     throw new Error("This connection cannot save review configuration.");
   const config = validateConfig(draft);
+  for (const lane of config.lanes) {
+    const saved = previous?.config.lanes.find((item) => item.id === lane.id);
+    // Preserve readable legacy lanes until they are edited; new/changed lanes require rules.
+    if (
+      !lane.routing?.rules.length &&
+      JSON.stringify(saved) !== JSON.stringify(lane)
+    )
+      throw new Error(
+        `Add at least one routing rule to ${lane.name} before saving.`,
+      );
+  }
+
   const artifactId = await identity(channel, config.repository);
   if (
     previous &&
diff --git a/src/bundled/review-configuration/review-configuration.css b/src/bundled/review-configuration/review-configuration.css
index d947623818..a849ebea7b 100644
--- a/src/bundled/review-configuration/review-configuration.css
+++ b/src/bundled/review-configuration/review-configuration.css
@@ -26,7 +26,7 @@
 .review-config-content p {
   margin: 0;
 }
-.review-config-reviewers span {
+.review-config-agent-row > span:not(.buzz-avatar-status) {
   overflow-wrap: anywhere;
   min-width: 0;
 }
@@ -72,3 +72,33 @@
     grid-template-columns: minmax(0, 1fr);
   }
 }
+
+.review-config-lane-card,
+.review-config-rule-card {
+  display: flex;
+  flex-direction: column;
+  gap: var(--space-4);
+  padding-block: var(--space-4);
+  min-width: 0;
+}
+.review-config-rule-heading,
+.review-config-agent-row {
+  display: flex;
+  align-items: center;
+  gap: var(--space-3);
+  min-width: 0;
+}
+.review-config-rule-heading {
+  justify-content: space-between;
+}
+.review-config-agent-row > .buzz-button {
+  margin-inline-start: auto;
+}
+.review-config-summary-section {
+  display: grid;
+  gap: var(--space-2);
+}
+.review-config-summary-section ul {
+  margin: 0;
+  padding-inline-start: var(--space-5);
+}

From 99b22e42ad918621f4ca386e9cd66e3ba9ef2172 Mon Sep 17 00:00:00 2001
From: Ravneet Arora <rarora@squareup.com>
Date: Thu, 12 Nov 2026 13:52:43 -0500
Subject: [PATCH 07/17] feat(review): separate one-step PR submission and
 notify existing reviewers

Co-authored-by: maincourse <37ce551b493d4a998caf030929c47bce0b6a0e43f1178b3a63c4151d7c16b76e@buzz.block.builderlab.xyz>
Signed-off-by: Ravneet Arora <rarora@squareup.com>
---
 docs/buzz-help.md                             |  42 +-
 src/bundled/review-configuration/README.md    | 119 +--
 .../ReviewConfigurationPage.test.tsx          | 105 +--
 .../ReviewConfigurationPage.tsx               | 481 +++++-------
 .../ReviewSubmissions.test.tsx                | 357 +++++----
 .../ReviewSubmissions.tsx                     | 702 +++++++-----------
 src/bundled/review-configuration/index.tsx    |  30 +-
 .../review-configuration/manifest.json        |   2 +-
 .../review-configuration.css                  |   4 +
 .../review-configuration/submissions.test.ts  | 152 ++++
 .../review-configuration/submissions.ts       |  85 ++-
 11 files changed, 1017 insertions(+), 1062 deletions(-)

diff --git a/docs/buzz-help.md b/docs/buzz-help.md
index 4841709b85..5ac2276032 100644
--- a/docs/buzz-help.md
+++ b/docs/buzz-help.md
@@ -1161,29 +1161,27 @@ confirmation. **Delete team** asks first; it doesn't delete the team's agents.
   reads the latest saved versions. Settings live on the community relay and are
   visible to channel readers; members who can post can edit them. A conflicting
   edit preserves your draft: copy your changes before cancelling and reloading.
-  **Submit PR** on the repository list finds the configured repository from a full
-  GitHub PR URL, then opens its matching-lane preview flow.
-  Open one repository at a time. **Configuration** shows lane cards with agents, instructions, and rules;
-  **Pull requests** contains **Submit PR** and that repository’s **Existing PRs**.
-  **Edit lane** opens one lane. **Save lane** persists it before **Add lane** can start another.
+  **Review Configuration** contains repository and lane settings only. **Edit lane**
+  opens one lane; **Save lane** persists it before **Add lane** starts another.
   **Back to lanes** cancels the editor; **Back to repositories** returns to the list.
-  Save or cancel an open draft before switching views.
-  **Submit PR** accepts a PR number or URL for that repository and one reviewer
-  per matching lane. Every new or edited lane requires at least one all/any routing rule
-  matching title text, exact labels, changed-file counts, or path patterns such as `src/**/*.tsx`.
-  Earlier rule-free lanes still match every PR; editing them requires adding a rule.
-  **Load PR details** previews matching lanes; zero matches sends nothing.
-  **Start review threads** rechecks the PR, saves the instructions, and creates
-  one thread per matching lane, mentioning its reviewer. Earlier submissions
-  retain their existing overview links. The page remembers your selected channel. The list retains delivery
-  status and **Open thread** actions. Repeating a PR reuses its saved submission;
-  **Resume submission** retries interrupted delivery from the original browser
-  profile. Reviewers must be owned by the signed-in identity and already belong
-  to the channel. A connected desktop agent runtime is needed for replies; delivery
-  alone does not mean a review started. Desktop uses signed-in GitHub access;
-  browser metadata reads support public PRs only and may hit GitHub rate limits.
-  PRs above 3,000 changed files or 100 labels are unsupported. Pinned reviewer
-  checkouts, review verdicts, resubmission rounds, and reminders are not implemented.
+  Every new or edited lane requires at least one all/any routing rule matching
+  title text, labels, changed-file counts, or paths such as `src/**/*.tsx`.
+  Earlier rule-free lanes still match every PR until edited.
+  The separate **Submit PR** sidebar page has a full GitHub PR URL field and a
+  Submit button. It finds the repository in the selected review channel, reads
+  current PR details, and assigns the first configured reviewer in each matching
+  lane. Missing configuration or zero matching lanes sends nothing. Results show
+  assigned agents and their thread buttons; **Existing PRs** lists previous submissions.
+  Submitting an existing PR reuses its saved reviewers and threads and mentions
+  them again in those threads. Incomplete initial delivery resumes from the original
+  browser profile. An interrupted notification retries its saved messages.
+  No configuration controls appear on Submit PR. Both pages remember the selected
+  review channel. Reviewers must be owned by the signed-in identity and already
+  belong to the channel. A connected agent runtime is needed for replies;
+  delivery alone does not mean a review started. Desktop uses signed-in GitHub
+  access; browser metadata reads support public PRs and may hit rate limits.
+  PRs above 3,000 changed files or 100 labels are unsupported. This does not post
+  GitHub comments, track verdicts, pin reviewer checkouts, or schedule reminders.
 - A plugin's details in Manage plugins link to the Settings sections that hold
   its settings: sections it adds, such as GitHub comment authors, and Decisions
   API for a decision provider, such as TypeSafe. Only sections the Settings
diff --git a/src/bundled/review-configuration/README.md b/src/bundled/review-configuration/README.md
index a39bb9aed3..1d1cd14dfd 100644
--- a/src/bundled/review-configuration/README.md
+++ b/src/bundled/review-configuration/README.md
@@ -3,34 +3,35 @@
 An optional bundled plugin with a separate sidebar page for repository review
 settings. Enable **Review Configuration** in Settings → Plugins → Manage plugins.
 Choose a channel, register a GitHub repository, add named lanes, reviewer agents, and instructions,
-and save. Open a repository row to work with one repository at a time. Its **Configuration**
-section contains lane settings; **Pull requests** contains Submit PR and Existing PRs.
-Saved lane cards show their agents, instructions, and rules. **Edit lane** opens one lane;
-**Save lane** persists it before another can be added with the bottom **Add lane** button.
-**Back to lanes** cancels the editor; **Back to repositories** returns to the list. Cancel or save a draft before
-switching sections or repositories. These are local page sections: reload returns
-to the repository list; they do not create separate shell tabs or history visits. The page
-remembers your channel per identity/community and selects it automatically when
-only one eligible channel is available.
-
-From the repository list, **Submit PR** accepts a full GitHub PR URL and finds
-its configured repository in the selected channel. Unknown repositories must be
-registered first. The matched repository opens in Pull requests with the URL
-filled in; Load PR details previews its matching lanes before sending.
-
-In a repository’s **Pull requests** section, use **Submit PR**, enter a PR number or URL, and
-load PR details to preview matching lanes, then choose one configured reviewer
-per matching lane. **Start review threads** saves the instruction snapshot,
-creates one thread per matching lane with no overview, and mentions
-each selected reviewer with the complete lane instructions. The list retains
-thread links and delivery status. Sending does not prove that an agent is running
-or reviewing. No model process or reminder timer is started by this plugin.
+and save. Open a repository row to manage its lanes. Saved cards show agents,
+instructions, and routing rules. **Edit lane** opens one lane; **Save lane** persists
+it before another can be added. **Back to lanes** cancels edits; **Back to repositories**
+returns to the list. Configuration contains no PR submission controls.
+
+The separate **Submit PR** sidebar page has a full GitHub PR URL field and one
+Submit button. It finds the saved repository in the selected channel, loads current
+PR metadata, and assigns the first configured reviewer per matching lane. Missing
+configuration, unavailable reviewers, and zero matching lanes produce an error
+without starting threads. Results show assigned reviewers and thread buttons.
+Existing PRs are listed below, with optional details collapsed.
+
+Submitting an already-delivered PR sends a reviewer mention in each saved lane
+thread. It preserves the saved reviewers and instructions and creates no new
+threads or review rounds. Incomplete original submissions resume delivery from
+the original browser profile instead. These actions run only on Submit; opening
+the page or a thread never dispatches messages.
+
+Both sidebar pages use the shell's page navigation. Repository and lane editing
+remain local sections; reloading returns Configuration to its repository list.
+The channel selection is remembered per identity/community; one eligible channel
+is selected automatically. Submit results can be recovered from Existing PRs
+following reload; navigation never replays Submit automatically.
 
 ## Getting started
 
 Enable this plugin in **Settings → Plugins → Manage plugins**, then open its
 sidebar entry. Choose a channel and register a repository. For each lane, select
-reviewer agents, enter instructions, and configure at least one routing rule, then save. Open its Configuration section to edit settings.
+reviewer agents, enter instructions, and configure at least one routing rule, then save. Open the repository to edit settings.
 These selections do not start reviews or grant agents access to the channel.
 
 ---
@@ -101,39 +102,43 @@ lab with registered identities alone cannot execute a review.
 ## Submissions and recovery
 
 One `buzz.review.submission` artifact per channel/repository/PR stores the selected
-reviewers, instructions, configuration revision, and message IDs. Repeating a PR
-returns that record; resubmission rounds are not implemented. The PR URL is
-validated against the repository. GitHub title, labels, file count, changed paths,
-and base/head commits are read before preview and rechecked before submission.
-If they change, confirm the updated preview before sending. The reviewer is
-asked to report the exact commit reviewed; this does not pin their checkout.
-Earlier version-1 submissions retain their overview and original thread IDs for
-recovery. New version-2 submissions store only matching lanes and their threads. This does not post a GitHub review or claim an approval.
-
-Artifact create/CAS prevents competing submissions. A local profile identifier
-and Web Lock serialize delivery in the submitting profile; outbox recovery keeps
-the exact messages through lost receipts or interrupted artifact saves.
-**Resume submission** explicitly retries saved messages. A duplicate submission
-first returns the saved preview; it never silently dispatches an older selection. Other profiles can read
-the links but cannot take over incomplete delivery. If the original profile's
-recovery storage is lost, delivery stops instead of risking duplicate threads.
-Dispatch intent is saved before enqueueing. If that intent survives but both the
-message ID and recovery journal are missing, the row shows unconfirmed delivery
-and stops. A proven rejection before enqueue clears that intent for a later retry.
-A missing outbox message with a known ID is checked against the relay before
-recording delivery.
-No background retries, polling, or model runtime are added.
-
-Opening Pull requests adds one bounded submissions read (latest 100, with truncation
-notice). Submission explicitly reads the current record and reviewer profiles,
-refreshes agent choices, and uses the outbox's per-message membership preflight.
-Reconnect introduces no new plugin reads.
-
-Try Submit PR → Load PR details → Start review threads → reload → Open a lane thread. Check that
-the PR, reviewer mention and complete instructions are present. Submit the same
-PR again: it must reuse the saved threads. Test interrupted delivery with Resume
-from the same browser profile. Reminders, review verdict tracking, GitHub status
-synchronization, and new review rounds remain future work.
+reviewers, instructions, configuration revision, and message IDs. New version-2
+submissions store only matching lane threads. Earlier version-1 submissions retain
+their overview and original lane IDs. Explicit resubmission notifies lane reviewers
+only, never the overview. Reviewer ownership and availability are revalidated;
+the outbox verifies channel membership before publishing mentions.
+
+The URL identifies the repository. Each Submit reads saved configuration fresh.
+For a new submission, the reader obtains complete and consistent GitHub title,
+labels, file count, paths, and base/head commits before routing. Existing submissions
+reuse their snapshot without requiring a GitHub read. Reviewers must verify the
+current PR and report the commit they reviewed; this does not pin their checkout.
+
+Artifact create/CAS prevents competing initial submissions. A Web Lock serializes
+operations in the same profile. Original delivery belongs to the submitting profile;
+other profiles may read its links but cannot take over incomplete initial delivery.
+Dispatch intent is saved before enqueue, and the durable outbox retains message
+identities through interrupted saves or uncertain receipts. Missing recovery data
+stops delivery instead of creating replacement threads.
+
+Explicit notifications use a recovery key per saved lane thread in the current
+identity/community's outbox. Successful receipts remain until the batch succeeds,
+so retrying a partial batch does not recreate its acknowledged messages. After
+completion another explicit Submit starts another notification batch. These are
+user-triggered follow-ups, not an exactly-once cross-device notification guarantee.
+A failed notification leaves existing thread buttons available and reports failure.
+
+Opening Submit PR reads the latest 100 submissions once, with truncation/error
+feedback. Submit reads configurations and the current submission, then verifies
+reviewer profiles and ownership before dispatch. No polling or reconnect reads
+are added. No GitHub comments, verdict synchronization, scheduled reminders, or
+agent runtime are added.
+
+Try a fresh test PR URL → Submit PR → Open a lane thread. Check its URL, reviewer
+mention, and complete instructions. Submit the same URL again: the same threads
+must receive follow-ups. Check unknown repositories, zero matching lanes, and
+interrupted delivery. Required channel membership and connected reviewer runtimes
+are separate from configuration.
 
 ## Routing rules
 
@@ -150,4 +155,4 @@ Desktop reads use the existing signed-in GitHub CLI. Browser reads use GitHub's
 public API without credentials, so private PRs and rate-limited requests need the
 desktop host. The reader rejects incomplete/changing metadata and supports at
 most 3,000 changed files and 100 labels; it never routes on a truncated file list.
-Metadata is fetched only on Load PR details and submission; there is no poller.
+Metadata is fetched during new submission only; there is no poller.
diff --git a/src/bundled/review-configuration/ReviewConfigurationPage.test.tsx b/src/bundled/review-configuration/ReviewConfigurationPage.test.tsx
index 20947f9adf..67599dabe4 100644
--- a/src/bundled/review-configuration/ReviewConfigurationPage.test.tsx
+++ b/src/bundled/review-configuration/ReviewConfigurationPage.test.tsx
@@ -483,64 +483,33 @@ it("preserves the remembered channel until pending metadata finishes", async ()
   );
 });
 
-it("separates a repository's PR activity and guards drafts before switching views", async () => {
+it("keeps submission controls out of configuration and preserves lane drafts", async () => {
   const test = fixture();
   render(<ReviewConfigurationCommunity session={test.session} />);
   const user = await openDraft();
   await user.click(screen.getByRole("button", { name: "Save lane" }));
   await screen.findByText("Saved example-org/project.");
   expect(screen.queryByRole("region", { name: "PR submissions" })).toBeNull();
-  await user.click(screen.getByRole("tab", { name: "Pull requests" }));
-  await screen.findByRole("button", { name: "Submit PR" });
-  expect(
-    screen.queryByRole("button", { name: "Edit General lane" }),
-  ).toBeNull();
-  await user.click(screen.getByRole("button", { name: "Submit PR" }));
-  expect(
-    screen.queryByRole("combobox", { name: "Repository to review" }),
-  ).toBeNull();
-  expect(
-    screen
-      .getByRole("tab", { name: "Configuration" })
-      .getAttribute("aria-disabled"),
-  ).toBe("true");
-  expect(
-    (
-      screen.getByRole("button", {
-        name: "Back to repositories",
-      }) as HTMLButtonElement
-    ).disabled,
-  ).toBe(true);
-  await user.click(screen.getByRole("button", { name: "Cancel" }));
-  await user.click(screen.getByRole("tab", { name: "Configuration" }));
+  expect(screen.queryByRole("button", { name: "Submit PR" })).toBeNull();
   await user.click(screen.getByRole("button", { name: "Edit General lane" }));
   expect(
-    screen
-      .getByRole("tab", { name: "Pull requests" })
-      .getAttribute("aria-disabled"),
-  ).toBe("true");
+    screen.queryByRole("button", { name: "Back to repositories" }),
+  ).toBeNull();
   const field = screen.getByRole("textbox", { name: "Instructions" });
   await user.clear(field);
-  await user.type(field, "Preserve collapsed drafts");
-  expect(
-    (
-      screen.getByRole("textbox", {
-        name: "Instructions",
-      }) as HTMLTextAreaElement
-    ).value,
-  ).toBe("Preserve collapsed drafts");
+  await user.type(field, "Preserve draft");
+  expect((field as HTMLTextAreaElement).value).toBe("Preserve draft");
   await user.click(screen.getByRole("button", { name: "Cancel" }));
   await user.click(
     screen.getByRole("button", { name: "Back to repositories" }),
   );
+  expect(screen.queryByRole("button", { name: "Submit PR" })).toBeNull();
   await user.click(
     screen.getByRole("button", { name: "Open example-org/project" }),
   );
   expect(
-    screen
-      .getByRole("tab", { name: "Configuration" })
-      .getAttribute("aria-selected"),
-  ).toBe("true");
+    screen.getByRole("button", { name: "Edit General lane" }),
+  ).toBeTruthy();
 });
 
 it("blocks editor entry while a reload can replace the repository", async () => {
@@ -578,57 +547,15 @@ it("blocks editor entry while a reload can replace the repository", async () =>
   ).toBe(false);
 });
 
-it("maps a pasted URL to its configured repository and keeps unknown URLs editable", async () => {
+it("opens the separate submit page without repository or lane configuration", async () => {
   const test = fixture();
-  const readPull = vi.fn(async () => ({
-    title: "Review this change",
-    labels: [],
-    changedFiles: 1,
-    repository: "example-org/project",
-    pr: 42,
-    paths: ["src/index.ts"],
-    head: "a".repeat(40),
-    base: "b".repeat(40),
-  }));
-  render(
-    <ReviewConfigurationCommunity session={test.session} readPull={readPull} />,
-  );
-  const user = await openDraft();
-  await user.click(screen.getByRole("button", { name: "Save lane" }));
-  await screen.findByText("Saved example-org/project.");
-  await user.click(
-    screen.getByRole("button", { name: "Back to repositories" }),
-  );
-  await user.click(screen.getByRole("button", { name: "Submit PR" }));
-  const input = screen.getByRole("textbox", { name: "GitHub PR URL" });
-  await user.type(input, "https://github.com/example-org/unknown/pull/42");
-  await user.click(screen.getByRole("button", { name: "Continue" }));
-  expect((await screen.findByRole("alert")).textContent).toContain(
-    "not configured",
-  );
-  await user.clear(input);
-  await user.type(input, "https://github.com/example-org/project/pull/42");
-  await user.click(screen.getByRole("button", { name: "Continue" }));
+  render(<ReviewConfigurationCommunity session={test.session} submit />);
+  await screen.findByRole("textbox", { name: "GitHub PR URL" });
+  expect(screen.getByRole("button", { name: "Submit PR" })).toBeTruthy();
   expect(
-    (
-      (await screen.findByRole("textbox", {
-        name: "Pull request",
-      })) as HTMLInputElement
-    ).value,
-  ).toBe("https://github.com/example-org/project/pull/42");
-  await user.click(screen.getByRole("button", { name: "Load PR details" }));
-  await waitFor(() =>
-    expect(readPull).toHaveBeenCalledWith(
-      "example-org/project",
-      42,
-      expect.any(AbortSignal),
-    ),
-  );
-  expect(test.publish).toHaveBeenCalledTimes(1);
-  await user.click(screen.getByRole("button", { name: "Cancel" }));
-  await user.click(screen.getByRole("tab", { name: "Configuration" }));
-  await user.click(screen.getByRole("tab", { name: "Pull requests" }));
-  expect(screen.queryByRole("textbox", { name: "Pull request" })).toBeNull();
+    screen.queryByRole("button", { name: "Register repository" }),
+  ).toBeNull();
+  expect(screen.queryByText("Repositories")).toBeNull();
 });
 
 it("requires a routing value and saves each lane before allowing another", async () => {
diff --git a/src/bundled/review-configuration/ReviewConfigurationPage.tsx b/src/bundled/review-configuration/ReviewConfigurationPage.tsx
index f312aa198c..e3e6ad3ec9 100644
--- a/src/bundled/review-configuration/ReviewConfigurationPage.tsx
+++ b/src/bundled/review-configuration/ReviewConfigurationPage.tsx
@@ -1,16 +1,9 @@
 import { createPullReader, type ReadPull } from "./pull-facts";
 const publicPullReader = createPullReader();
 import { LaneRules, ruleDescription } from "./LaneRules";
-import {
-  useCallback,
-  useEffect,
-  useRef,
-  useState,
-  type ReactNode,
-} from "react";
+import { useEffect, useRef, useState, type ReactNode } from "react";
 import { useAgentChoices } from "../../features/agents/use-choices";
 import { ReviewSubmissions } from "./ReviewSubmissions";
-import { pullRepository } from "./submissions";
 import type { Navigation } from "../../features/navigation/controller";
 import { splitPartition } from "../../features/relay/partition";
 import { LaneReviewers, ReviewerIdentity } from "./LaneReviewers";
@@ -22,7 +15,6 @@ import {
   ListChecksIcon,
 } from "../../shared/design-system/icons";
 import { NavigationItem } from "../../shared/design-system/ui/NavigationItem";
-import { Tabs } from "../../shared/design-system/ui/Tabs";
 import { Button } from "../../shared/design-system/ui/Button";
 import { Field } from "../../shared/design-system/ui/Field";
 import { FullPageSurface } from "../../shared/design-system/ui/FullPageSurface";
@@ -45,17 +37,19 @@ import {
 } from "./configuration";
 import "./review-configuration.css";
 
-function Frame({ children }: { children: ReactNode }) {
+function Frame({
+  children,
+  submit = false,
+}: {
+  children: ReactNode;
+  submit?: boolean;
+}) {
+  const title = submit ? "Submit PR" : "Review Configuration";
   return (
-    <FullPageSurface aria-label="Review Configuration">
+    <FullPageSurface aria-label={title}>
       <div className="review-config-page text-body">
         <PanelHeader
-          title={
-            <PanelHeaderLabel
-              title="Review Configuration"
-              icon={<ListChecksIcon />}
-            />
-          }
+          title={<PanelHeaderLabel title={title} icon={<ListChecksIcon />} />}
         />
         <div className="review-config-scroll">
           <div className="review-config-content">{children}</div>
@@ -69,7 +63,9 @@ export function ReviewConfigurationPage({
   relay,
   navigator,
   readPull = publicPullReader,
+  submit = false,
 }: {
+  submit?: boolean;
   relay: RelayData;
   navigator?: Navigation;
   readPull?: ReadPull;
@@ -80,6 +76,7 @@ export function ReviewConfigurationPage({
       <ReviewConfigurationCommunity
         key={`${connection.scope}:${connection.generation}`}
         session={connection.session}
+        submit={submit}
         readPull={readPull}
         onOpenThread={async (channelId, id) => {
           const scope = splitPartition(connection.scope ?? "");
@@ -99,11 +96,11 @@ export function ReviewConfigurationPage({
       />
     );
   return (
-    <Frame>
+    <Frame submit={submit}>
       <p>
         {connection.status === "connecting"
           ? "Connecting to your community…"
-          : "Connect to a community to configure reviews."}
+          : "Connect to a community to use reviews."}
       </p>
       {connection.status === "error" && (
         <>
@@ -119,8 +116,10 @@ export function ReviewConfigurationCommunity({
   session,
   onOpenThread,
   readPull = publicPullReader,
+  submit = false,
 }: {
   session: RelaySession;
+  submit?: boolean;
   readPull?: ReadPull;
   onOpenThread?: ((channel: string, id: string) => Promise<void>) | undefined;
 }) {
@@ -165,25 +164,31 @@ export function ReviewConfigurationCommunity({
     !selected.readOnly &&
     !!session.configArtifactWriter;
   return (
-    <Frame>
-      <Select
-        label="Review channel"
-        variant="field"
-        value={channel}
-        onValueChange={setChannel}
-        disabled={editing}
-        placeholder="Choose a channel"
-        groups={[
-          {
-            label: "Channels",
-            options: channels.map((item) => ({
-              value: item.id,
-              label: item.name,
-            })),
-          },
-        ]}
-        description="Repositories and reviews are shared with this channel."
-      />
+    <Frame submit={submit}>
+      {submit && channels.length === 1 ? (
+        <p className="text-caption text-subtle">
+          Review channel: {selected?.name}
+        </p>
+      ) : (
+        <Select
+          label="Review channel"
+          variant="field"
+          value={channel}
+          onValueChange={setChannel}
+          disabled={editing}
+          placeholder="Choose a channel"
+          groups={[
+            {
+              label: "Channels",
+              options: channels.map((item) => ({
+                value: item.id,
+                label: item.name,
+              })),
+            },
+          ]}
+          description="Repositories and reviews are shared with this channel."
+        />
+      )}
       {list.status === "loading" && <p role="status">Loading channels…</p>}
       {list.status === "error" && (
         <p role="alert">Could not load channels. Reconnect to try again.</p>
@@ -194,17 +199,26 @@ export function ReviewConfigurationCommunity({
           draft is preserved.
         </p>
       )}
-      {channel && (
-        <ChannelConfiguration
-          key={channel}
-          session={session}
-          channel={channel}
-          writable={writable}
-          onEditingChange={setEditing}
-          onOpenThread={onOpenThread}
-          readPull={readPull}
-        />
-      )}
+      {channel &&
+        (submit ? (
+          <ReviewSubmissions
+            key={channel}
+            session={session}
+            channel={channel}
+            writable={writable}
+            onEditingChange={setEditing}
+            onOpenThread={onOpenThread}
+            readPull={readPull}
+          />
+        ) : (
+          <ChannelConfiguration
+            key={channel}
+            session={session}
+            channel={channel}
+            writable={writable}
+            onEditingChange={setEditing}
+          />
+        ))}
     </Frame>
   );
 }
@@ -214,27 +228,14 @@ function ChannelConfiguration({
   channel,
   writable,
   onEditingChange,
-  onOpenThread,
-  readPull,
 }: {
   session: RelaySession;
-  readPull: ReadPull;
   channel: string;
   writable: boolean;
   onEditingChange: (editing: boolean) => void;
-  onOpenThread?: ((channel: string, id: string) => Promise<void>) | undefined;
 }) {
   const choices = useAgentChoices(session, true, true);
   const [laneId, setLaneId] = useState<string>();
-  const [submitting, setSubmitting] = useState(false);
-  const [lookup, setLookup] = useState(false);
-  const [pullUrl, setPullUrl] = useState("");
-  const [lookupError, setLookupError] = useState("");
-  const [initialPull, setInitialPull] = useState("");
-  const submissionEditing = useCallback((editing: boolean) => {
-    setSubmitting(editing);
-    if (!editing) setInitialPull("");
-  }, []);
   const [rows, setRows] = useState<SavedReviewConfig[]>([]);
   const [loading, setLoading] = useState(true);
   const [error, setError] = useState("");
@@ -244,14 +245,11 @@ function ChannelConfiguration({
   const [reload, setReload] = useState(0);
   const [editor, setEditor] = useState<SavedReviewConfig | "new">();
   const [repository, setRepository] = useState("");
-  const [section, setSection] = useState<"configuration" | "pulls">(
-    "configuration",
-  );
   const selected = rows.find((row) => row.config.repository === repository);
   const editorTrigger = useRef<HTMLElement | null>(null);
   const lanesRegion = useRef<HTMLElement | null>(null);
   useEffect(() => {
-    onEditingChange(editor !== undefined || submitting || lookup);
+    onEditingChange(editor !== undefined);
     if (editor === undefined) {
       const trigger = editorTrigger.current;
       if (trigger?.isConnected && !trigger.matches(":disabled"))
@@ -259,7 +257,7 @@ function ChannelConfiguration({
       else lanesRegion.current?.focus();
     }
     return () => onEditingChange(false);
-  }, [editor, submitting, lookup, onEditingChange]);
+  }, [editor, onEditingChange]);
   // biome-ignore lint/correctness/useExhaustiveDependencies: Reload explicitly requests a fresh snapshot.
   useEffect(() => {
     const controller = new AbortController();
@@ -322,7 +320,7 @@ function ChannelConfiguration({
           <InlineHeader title="Repositories" />
           <div className="review-config-actions">
             <Button
-              disabled={loading || lookup}
+              disabled={loading}
               onClick={() => setReload((value) => value + 1)}
             >
               Reload
@@ -330,9 +328,7 @@ function ChannelConfiguration({
             <Button
               ref={editorTrigger}
               variant="prominent"
-              disabled={
-                loading || lookup || !!error || !writable || remaining <= 0
-              }
+              disabled={loading || !!error || !writable || remaining <= 0}
               onClick={(event) => {
                 editorTrigger.current = event.currentTarget;
                 setNotice("");
@@ -341,67 +337,7 @@ function ChannelConfiguration({
             >
               Register repository
             </Button>
-            <Button
-              disabled={
-                loading || lookup || !!error || !writable || !rows.length
-              }
-              onClick={() => {
-                setLookup(true);
-                setLookupError("");
-              }}
-            >
-              Submit PR
-            </Button>
           </div>
-          {lookup && (
-            <form
-              className="review-config-form"
-              onSubmit={(event) => {
-                event.preventDefault();
-                try {
-                  const name = pullRepository(pullUrl);
-                  const match = rows.find(
-                    (row) => row.config.repository === name,
-                  );
-                  if (!match)
-                    throw new Error(
-                      `${name} is not configured in this channel. Register it before submitting.`,
-                    );
-                  setRepository(name);
-                  setSection("pulls");
-                  setInitialPull(pullUrl.trim());
-                  setLookup(false);
-                } catch (reason) {
-                  setLookupError(
-                    reason instanceof Error
-                      ? reason.message
-                      : "Could not find repository.",
-                  );
-                }
-              }}
-            >
-              <Field
-                label="GitHub PR URL"
-                description="We’ll find its configured repository and match its lane rules."
-              >
-                <Input
-                  autoFocus
-                  required
-                  maxLength={300}
-                  value={pullUrl}
-                  onValueChange={setPullUrl}
-                  placeholder="https://github.com/example-org/project/pull/123"
-                />
-              </Field>
-              {lookupError && <p role="alert">{lookupError}</p>}
-              <div className="review-config-actions">
-                <Button onClick={() => setLookup(false)}>Cancel</Button>
-                <Button type="submit" variant="prominent">
-                  Continue
-                </Button>
-              </div>
-            </form>
-          )}
           {loading ? (
             <p role="status">Loading configurations…</p>
           ) : error ? (
@@ -413,7 +349,6 @@ function ChannelConfiguration({
                   key={row.artifactId}
                   aria-label={`Open ${row.config.repository}`}
                   multiline
-                  disabled={lookup}
                   label={
                     <span className="review-config-repository-label">
                       <span>{row.config.repository}</span>
@@ -425,7 +360,6 @@ function ChannelConfiguration({
                   trailing="Open"
                   onClick={() => {
                     setRepository(row.config.repository);
-                    setSection("configuration");
                     setNotice("");
                   }}
                 />
@@ -445,7 +379,6 @@ function ChannelConfiguration({
           {!editor && (
             <div>
               <Button
-                disabled={submitting}
                 onClick={() => {
                   setRepository("");
                   setNotice("");
@@ -458,176 +391,140 @@ function ChannelConfiguration({
           {selected && (
             <>
               <InlineHeader title={selected.config.repository} />
-              <Tabs
-                variant="panel"
-                label="Repository sections"
-                value={section}
-                items={[
-                  {
-                    value: "configuration",
-                    label: "Configuration",
-                    disabled: !!editor || submitting,
-                  },
-                  {
-                    value: "pulls",
-                    label: "Pull requests",
-                    disabled: !!editor || submitting,
-                  },
-                ]}
-                onValueChange={setSection}
-                renderPanel={(tab) =>
-                  tab === "configuration" ? (
-                    <section
-                      className="review-config-form"
-                      aria-label="Repository configuration"
-                      ref={lanesRegion}
-                      tabIndex={-1}
-                    >
-                      {editor ? (
-                        <ConfigurationEditor
-                          key={editor === "new" ? "new" : editor.revision}
-                          session={session}
-                          channel={channel}
-                          writable={writable}
-                          previous={editor === "new" ? undefined : editor}
-                          laneId={laneId}
-                          existing={rows}
-                          onCancel={() => setEditor(undefined)}
-                          onSaved={saved}
-                        />
-                      ) : (
-                        <>
+              <section
+                className="review-config-form"
+                aria-label="Repository configuration"
+                ref={lanesRegion}
+                tabIndex={-1}
+              >
+                {editor ? (
+                  <ConfigurationEditor
+                    key={editor === "new" ? "new" : editor.revision}
+                    session={session}
+                    channel={channel}
+                    writable={writable}
+                    previous={editor === "new" ? undefined : editor}
+                    laneId={laneId}
+                    existing={rows}
+                    onCancel={() => setEditor(undefined)}
+                    onSaved={saved}
+                  />
+                ) : (
+                  <>
+                    <InlineHeader
+                      title="Lanes"
+                      subtitle="Each lane has its own agents, instructions, and routing rules."
+                      actions={
+                        <Button
+                          disabled={loading}
+                          onClick={() => {
+                            setNotice("");
+                            setReload((value) => value + 1);
+                          }}
+                        >
+                          Reload
+                        </Button>
+                      }
+                    />
+                    {error && <p role="alert">{error}</p>}
+                    <SettingsGroup layout="cards">
+                      {selected.config.lanes.map((lane) => (
+                        <section
+                          key={lane.id}
+                          aria-label={`${lane.name} lane`}
+                          className="review-config-lane-card"
+                        >
                           <InlineHeader
-                            title="Lanes"
-                            subtitle="Each lane has its own agents, instructions, and routing rules."
+                            title={lane.name}
                             actions={
                               <Button
-                                disabled={loading}
+                                ref={(node) => {
+                                  if (laneId === lane.id)
+                                    editorTrigger.current = node;
+                                }}
+                                disabled={!writable || loading || !!error}
+                                aria-label={`Edit ${lane.name} lane`}
                                 onClick={() => {
+                                  setLaneId(lane.id);
                                   setNotice("");
-                                  setReload((value) => value + 1);
+                                  setEditor(selected);
                                 }}
                               >
-                                Reload
+                                Edit lane
                               </Button>
                             }
                           />
-                          {error && <p role="alert">{error}</p>}
-                          <SettingsGroup layout="cards">
-                            {selected.config.lanes.map((lane) => (
-                              <section
-                                key={lane.id}
-                                aria-label={`${lane.name} lane`}
-                                className="review-config-lane-card"
-                              >
-                                <InlineHeader
-                                  title={lane.name}
-                                  actions={
-                                    <Button
-                                      ref={(node) => {
-                                        if (laneId === lane.id)
-                                          editorTrigger.current = node;
-                                      }}
-                                      disabled={!writable || loading || !!error}
-                                      aria-label={`Edit ${lane.name} lane`}
-                                      onClick={() => {
-                                        setLaneId(lane.id);
-                                        setNotice("");
-                                        setEditor(selected);
-                                      }}
-                                    >
-                                      Edit lane
-                                    </Button>
-                                  }
+                          <div className="review-config-reviewers">
+                            <span className="text-caption text-subtle">
+                              Agents
+                            </span>
+                            {lane.reviewers.length ? (
+                              lane.reviewers.map((pubkey) => (
+                                <ReviewerIdentity
+                                  key={pubkey}
+                                  pubkey={pubkey}
+                                  choices={choices}
                                 />
-                                <div className="review-config-reviewers">
-                                  <span className="text-caption text-subtle">
-                                    Agents
-                                  </span>
-                                  {lane.reviewers.length ? (
-                                    lane.reviewers.map((pubkey) => (
-                                      <ReviewerIdentity
-                                        key={pubkey}
-                                        pubkey={pubkey}
-                                        choices={choices}
-                                      />
-                                    ))
-                                  ) : (
-                                    <p>No agents assigned.</p>
-                                  )}
-                                </div>
-                                <div className="review-config-summary-section">
-                                  <span className="text-caption text-subtle">
-                                    Routing rules ·{" "}
-                                    {lane.routing?.mode === "any"
-                                      ? "Match any"
-                                      : "Match all"}
-                                  </span>
-                                  {lane.routing?.rules.length ? (
-                                    <ul>
-                                      {lane.routing.rules.map((rule) => (
-                                        <li key={rule.id}>
-                                          {ruleDescription(rule)}
-                                        </li>
-                                      ))}
-                                    </ul>
-                                  ) : (
-                                    <p>
-                                      All PRs · Add a routing rule when editing
-                                      this lane.
-                                    </p>
-                                  )}
-                                </div>
-                                <div className="review-config-summary-section">
-                                  <span className="text-caption text-subtle">
-                                    Instructions
-                                  </span>
-                                  <p className="review-config-instructions">
-                                    {lane.instructions}
-                                  </p>
-                                </div>
-                              </section>
-                            ))}
-                          </SettingsGroup>
-                          <div>
-                            <Button
-                              ref={(node) => {
-                                if (!laneId) editorTrigger.current = node;
-                              }}
-                              variant="prominent"
-                              disabled={
-                                !writable ||
-                                loading ||
-                                !!error ||
-                                selected.config.lanes.length >= 12
-                              }
-                              onClick={() => {
-                                setLaneId(undefined);
-                                setNotice("");
-                                setEditor(selected);
-                              }}
-                            >
-                              Add lane
-                            </Button>
+                              ))
+                            ) : (
+                              <p>No agents assigned.</p>
+                            )}
                           </div>
-                        </>
-                      )}
-                    </section>
-                  ) : (
-                    <ReviewSubmissions
-                      session={session}
-                      channel={channel}
-                      configurations={[selected]}
-                      initialPull={initialPull}
-                      disabled={loading || !!error}
-                      writable={writable}
-                      onEditingChange={submissionEditing}
-                      onOpenThread={onOpenThread}
-                      readPull={readPull}
-                    />
-                  )
-                }
-              />
+                          <div className="review-config-summary-section">
+                            <span className="text-caption text-subtle">
+                              Routing rules ·{" "}
+                              {lane.routing?.mode === "any"
+                                ? "Match any"
+                                : "Match all"}
+                            </span>
+                            {lane.routing?.rules.length ? (
+                              <ul>
+                                {lane.routing.rules.map((rule) => (
+                                  <li key={rule.id}>{ruleDescription(rule)}</li>
+                                ))}
+                              </ul>
+                            ) : (
+                              <p>
+                                All PRs · Add a routing rule when editing this
+                                lane.
+                              </p>
+                            )}
+                          </div>
+                          <div className="review-config-summary-section">
+                            <span className="text-caption text-subtle">
+                              Instructions
+                            </span>
+                            <p className="review-config-instructions">
+                              {lane.instructions}
+                            </p>
+                          </div>
+                        </section>
+                      ))}
+                    </SettingsGroup>
+                    <div>
+                      <Button
+                        ref={(node) => {
+                          if (!laneId) editorTrigger.current = node;
+                        }}
+                        variant="prominent"
+                        disabled={
+                          !writable ||
+                          loading ||
+                          !!error ||
+                          selected.config.lanes.length >= 12
+                        }
+                        onClick={() => {
+                          setLaneId(undefined);
+                          setNotice("");
+                          setEditor(selected);
+                        }}
+                      >
+                        Add lane
+                      </Button>
+                    </div>
+                  </>
+                )}
+              </section>
             </>
           )}
           {editor === "new" && (
diff --git a/src/bundled/review-configuration/ReviewSubmissions.test.tsx b/src/bundled/review-configuration/ReviewSubmissions.test.tsx
index 349d600273..0361a8dc09 100644
--- a/src/bundled/review-configuration/ReviewSubmissions.test.tsx
+++ b/src/bundled/review-configuration/ReviewSubmissions.test.tsx
@@ -1,86 +1,89 @@
 // @vitest-environment jsdom
-import { act, cleanup, render, screen } from "@testing-library/react";
+import {
+  act,
+  cleanup,
+  render,
+  screen,
+  waitFor,
+  within,
+} from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
-import { afterEach, expect, it } from "vitest";
+import { afterEach, beforeEach, expect, it, vi } from "vitest";
 import type { RelaySession } from "../../features/relay/session";
 import { ReviewSubmissions } from "./ReviewSubmissions";
-import type { SavedReviewConfig } from "./configuration";
+import { loadConfigurations, type SavedReviewConfig } from "./configuration";
+import {
+  loadSubmissions,
+  submitReview,
+  type SavedSubmission,
+} from "./submissions";
 
+vi.mock("./configuration", async (original) => ({
+  ...(await original<typeof import("./configuration")>()),
+  loadConfigurations: vi.fn(),
+}));
+vi.mock("./submissions", async (original) => ({
+  ...(await original<typeof import("./submissions")>()),
+  loadSubmissions: vi.fn(),
+  submitReview: vi.fn(),
+}));
 afterEach(cleanup);
-
-it("waits for list reads before offering submission and restores trigger focus on cancel", async () => {
-  let finish: (events: []) => void = () => {};
-  const pending = new Promise<[]>((resolve) => {
-    finish = resolve;
+const configuration: SavedReviewConfig = {
+  revision: "b".repeat(64),
+  artifactId: "config",
+  config: {
+    version: 1,
+    repository: "example-org/project",
+    reminderMinutes: 15,
+    lanes: [
+      {
+        id: "ui",
+        name: "UI",
+        instructions: "Check keyboard access.",
+        reviewers: ["a".repeat(64)],
+      },
+    ],
+  },
+};
+const record: SavedSubmission = {
+  artifactId: "submission",
+  revision: "c".repeat(64),
+  value: {
+    version: 2,
+    pr: 42,
+    config: configuration.config,
+    configRevision: configuration.revision,
+    submitter: "d".repeat(64),
+    device: "device",
+    threads: [{ id: "e".repeat(64), delivered: true }],
+  },
+};
+beforeEach(() => {
+  vi.clearAllMocks();
+  vi.mocked(loadConfigurations).mockResolvedValue({
+    rows: [configuration],
+    unreadable: 0,
+    truncated: false,
   });
-  const choices = {
-    pending: false,
-    selectable: [{ pubkey: "a".repeat(64), name: "Reviewer" }],
-    archives: { status: "ready" },
-  };
-  const session = {
-    snapshotRead: () => pending,
-    agentChoices: {
-      subscribe: () => () => {},
-      snapshot: () => choices,
-      retain: () => () => {},
-      ensure() {},
+  vi.mocked(loadSubmissions).mockResolvedValue({ rows: [], warning: "" });
+  vi.mocked(submitReview).mockImplementation(
+    async (_s, _c, _config, _pr, _r, _signal, progress, _resume, facts) => {
+      if (typeof facts === "function") await facts();
+      progress({ ...record, value: { ...record.value, threads: [{}] } });
+      progress(record);
+      return record;
     },
-  } as unknown as RelaySession;
-  const configuration: SavedReviewConfig = {
-    revision: "b".repeat(64),
-    artifactId: "config",
-    config: {
-      version: 1,
-      repository: "example-org/project",
-      reminderMinutes: 15,
-      lanes: [
-        {
-          id: "general",
-          name: "General",
-          instructions: "Check tests.",
-          reviewers: ["a".repeat(64)],
-        },
-      ],
-    },
-  };
-  render(
-    <ReviewSubmissions
-      session={session}
-      channel="channel"
-      configurations={[configuration]}
-      disabled={false}
-      writable
-      onEditingChange={() => {}}
-    />,
-  );
-  const submit = screen.getByRole("button", {
-    name: "Submit PR",
-  }) as HTMLButtonElement;
-  expect(submit.disabled).toBe(true);
-  await act(async () => finish([]));
-  expect(submit.disabled).toBe(false);
-  const user = userEvent.setup();
-  await user.click(submit);
-  expect(screen.getByRole("textbox", { name: "Pull request" })).toBe(
-    document.activeElement,
   );
-  await user.click(screen.getByRole("button", { name: "Cancel" }));
-  expect(document.activeElement).toBe(submit);
 });
-
-it("clears changed PR previews, blocks unmatched lanes, and rechecks facts before any write", async () => {
-  const { vi } = await import("vitest");
+function fixture() {
+  const agents = [{ pubkey: "a".repeat(64), name: "UI Reviewer" }];
   const choices = {
+    identities: agents,
+    selectable: agents,
     pending: false,
-    selectable: [{ pubkey: "a".repeat(64), name: "Reviewer" }],
     archives: { status: "ready" },
   };
-  const snapshotRead = vi.fn(async () => []);
-  const publish = vi.fn();
   const session = {
-    snapshotRead,
-    configArtifactWriter: { publish },
     agentChoices: {
       subscribe: () => () => {},
       snapshot: () => choices,
@@ -88,79 +91,177 @@ it("clears changed PR previews, blocks unmatched lanes, and rechecks facts befor
       ensure() {},
     },
   } as unknown as RelaySession;
-  const configuration: SavedReviewConfig = {
-    revision: "b".repeat(64),
-    artifactId: "config",
-    config: {
-      version: 1,
-      repository: "example-org/project",
-      reminderMinutes: 15,
-      lanes: [
-        {
-          id: "ui",
-          name: "UI",
-          instructions: "Check keyboard navigation.",
-          reviewers: ["a".repeat(64)],
-          routing: {
-            mode: "all",
-            rules: [
-              { id: "ui", field: "title", operator: "contains", value: "UI" },
-            ],
-          },
-        },
-      ],
-    },
-  };
-  const facts = {
+  const readPull = vi.fn(async () => ({
     repository: "example-org/project",
     pr: 42,
-    title: "Improve UI",
-    labels: [],
+    title: "UI change",
+    labels: ["ui"],
     changedFiles: 1,
-    paths: ["src/ui.tsx"],
+    paths: ["ui.tsx"],
     head: "a".repeat(40),
     base: "b".repeat(40),
-  };
-  const readPull = vi.fn(async () => facts);
-  render(
+  }));
+  const onOpenThread = vi.fn(async () => {});
+  const editing = vi.fn();
+  const view = render(
     <ReviewSubmissions
       session={session}
       channel="channel"
-      configurations={[configuration]}
-      disabled={false}
       writable
-      onEditingChange={() => {}}
+      onEditingChange={editing}
+      onOpenThread={onOpenThread}
       readPull={readPull}
     />,
   );
-  const user = userEvent.setup();
-  await act(async () => {});
+  return {
+    ...view,
+    session,
+    readPull,
+    onOpenThread,
+    editing,
+    user: userEvent.setup(),
+  };
+}
+async function enter(
+  user: ReturnType<typeof userEvent.setup>,
+  url = "https://github.com/example-org/project/pull/42",
+) {
+  await user.type(screen.getByRole("textbox", { name: "GitHub PR URL" }), url);
   await user.click(screen.getByRole("button", { name: "Submit PR" }));
-  const input = screen.getByRole("textbox", { name: "Pull request" });
-  const start = screen.getByRole("button", {
-    name: "Start review threads",
-  }) as HTMLButtonElement;
-  await user.type(input, "42");
-  expect(start.disabled).toBe(true);
-  await user.click(screen.getByRole("button", { name: "Load PR details" }));
-  await screen.findByText("Matching lanes: UI");
-  expect(start.disabled).toBe(false);
-  await user.type(input, "3");
-  expect(start.disabled).toBe(true);
-  expect(screen.queryByText("Matching lanes: UI")).toBeNull();
-  await user.clear(input);
-  await user.type(input, "42");
-  readPull.mockResolvedValueOnce({ ...facts, title: "Backend change" });
-  await user.click(screen.getByRole("button", { name: "Load PR details" }));
-  await screen.findByText(/Matching lanes: None/);
-  expect(start.disabled).toBe(true);
-  await user.click(screen.getByRole("button", { name: "Load PR details" }));
-  await screen.findByText("Matching lanes: UI");
-  readPull.mockResolvedValueOnce({ ...facts, head: "c".repeat(40) });
-  await user.click(start);
+}
+it("submits a URL in one action and shows assigned reviewers and working thread controls", async () => {
+  const test = fixture();
+  await enter(test.user);
+  expect((await screen.findByRole("status")).textContent).toContain(
+    "Submitted — reviewers assigned",
+  );
+  expect(test.readPull).toHaveBeenCalledWith(
+    "example-org/project",
+    42,
+    expect.any(AbortSignal),
+  );
+  const result = screen.getByRole("region", { name: "Submission result" });
+  expect(within(result).getByText("UI Reviewer")).toBeTruthy();
+  await test.user.click(
+    within(result).getByRole("button", { name: "Open UI thread" }),
+  );
+  expect(test.onOpenThread).toHaveBeenCalledWith("channel", "e".repeat(64));
+  expect(screen.queryByRole("combobox")).toBeNull();
+  expect(screen.queryByRole("button", { name: "Load PR details" })).toBeNull();
+});
+it("keeps unknown repositories editable and never dispatches them", async () => {
+  const test = fixture();
+  await enter(test.user, "https://github.com/example-org/unknown/pull/42");
   expect((await screen.findByRole("alert")).textContent).toContain(
-    "The PR changed",
+    "not configured",
+  );
+  expect(submitReview).not.toHaveBeenCalled();
+  expect(test.readPull).not.toHaveBeenCalled();
+  await test.user.clear(screen.getByRole("textbox", { name: "GitHub PR URL" }));
+  await enter(test.user);
+  await waitFor(() =>
+    expect(screen.getByRole("status").textContent).toContain("Submitted"),
+  );
+});
+it("does not claim a repository is absent when configuration reads are incomplete", async () => {
+  vi.mocked(loadConfigurations).mockResolvedValue({
+    rows: [],
+    unreadable: 1,
+    truncated: false,
+  });
+  const test = fixture();
+  await enter(test.user);
+  expect((await screen.findByRole("alert")).textContent).toContain(
+    "Could not confirm",
+  );
+  expect(submitReview).not.toHaveBeenCalled();
+});
+it("shows existing threads and only claims notifications after successful delivery", async () => {
+  vi.mocked(submitReview).mockImplementation(
+    async (
+      _s,
+      _c,
+      _config,
+      _pr,
+      _r,
+      _signal,
+      progress,
+      _resume,
+      _facts,
+      existing,
+    ) => {
+      existing?.();
+      progress(record);
+      return record;
+    },
+  );
+  const test = fixture();
+  await enter(test.user);
+  await waitFor(() =>
+    expect(screen.getByRole("status").textContent).toContain(
+      "Already exists — reviewers notified",
+    ),
+  );
+  expect(test.readPull).not.toHaveBeenCalled();
+  vi.mocked(submitReview).mockImplementationOnce(
+    async (
+      _s,
+      _c,
+      _config,
+      _pr,
+      _r,
+      _signal,
+      progress,
+      _resume,
+      _facts,
+      existing,
+    ) => {
+      existing?.();
+      progress(record);
+      throw new Error("Notification rejected");
+    },
+  );
+  await test.user.click(screen.getByRole("button", { name: "Submit PR" }));
+  expect((await screen.findByRole("alert")).textContent).toContain(
+    "Notification rejected",
+  );
+  expect(screen.queryByRole("status")).toBeNull();
+  expect(screen.getByRole("button", { name: "Open UI thread" })).toBeTruthy();
+});
+it("guards repeated clicks and aborts pending work when its page unmounts", async () => {
+  let finish: () => void = () => {};
+  let signal: AbortSignal | undefined;
+  vi.mocked(submitReview).mockImplementationOnce(
+    async (_s, _c, _config, _pr, _r, pending) => {
+      signal = pending;
+      await new Promise<void>((resolve) => {
+        finish = resolve;
+      });
+      return record;
+    },
+  );
+  const test = fixture();
+  await enter(test.user);
+  await waitFor(() => expect(submitReview).toHaveBeenCalledTimes(1));
+  await test.user.click(screen.getByRole("button", { name: "Submit PR" }));
+  expect(submitReview).toHaveBeenCalledTimes(1);
+  expect((screen.getByRole("textbox") as HTMLInputElement).disabled).toBe(true);
+  test.unmount();
+  expect(signal?.aborted).toBe(true);
+  await act(async () => finish());
+});
+
+it("focuses the URL after selecting a previous PR without dispatching", async () => {
+  vi.mocked(loadSubmissions).mockResolvedValue({ rows: [record], warning: "" });
+  const test = fixture();
+  await test.user.click(
+    await screen.findByRole("button", { name: /example-org\/project#42/ }),
+  );
+  await test.user.click(screen.getByRole("button", { name: "Use this PR" }));
+  const input = screen.getByRole("textbox", { name: "GitHub PR URL" });
+  expect(document.activeElement).toBe(input);
+  expect((input as HTMLInputElement).value).toBe(
+    "https://github.com/example-org/project/pull/42",
   );
-  expect(publish).not.toHaveBeenCalled();
-  expect(snapshotRead).toHaveBeenCalledTimes(1);
+  expect(submitReview).not.toHaveBeenCalled();
 });
diff --git a/src/bundled/review-configuration/ReviewSubmissions.tsx b/src/bundled/review-configuration/ReviewSubmissions.tsx
index 8cae8ed670..06a1362910 100644
--- a/src/bundled/review-configuration/ReviewSubmissions.tsx
+++ b/src/bundled/review-configuration/ReviewSubmissions.tsx
@@ -1,543 +1,345 @@
-import { createPullReader, pullFingerprint, type ReadPull } from "./pull-facts";
-import { laneMatches, type PullFacts } from "./routing";
-const publicPullReader = createPullReader();
-import { useEffect, useMemo, useRef, useState } from "react";
+import { useEffect, useRef, useState } from "react";
 import { useAgentChoices } from "../../features/agents/use-choices";
 import type { RelaySession } from "../../features/relay/session";
 import { Accordion } from "../../shared/design-system/ui/Accordion";
 import { Button } from "../../shared/design-system/ui/Button";
 import { Field } from "../../shared/design-system/ui/Field";
 import { InlineHeader } from "../../shared/design-system/ui/Header";
+import { LoadingRegion } from "../../shared/design-system/ui/LoadingRegion";
 import { Input } from "../../shared/design-system/ui/Input";
-import { Select } from "../../shared/design-system/ui/Select";
-import { SettingsGroup } from "../../shared/design-system/ui/SettingsGroup";
-import type { SavedReviewConfig } from "./configuration";
+import { ReviewerIdentity } from "./LaneReviewers";
+import { loadConfigurations } from "./configuration";
+import { createPullReader, type ReadPull } from "./pull-facts";
 import {
   loadSubmissions,
   prUrl,
+  pullRepository,
+  pullRequest,
   submitReview,
   submissionLane,
-  pullRequest,
   type SavedSubmission,
 } from "./submissions";
 
+const publicPullReader = createPullReader();
+
 export function ReviewSubmissions({
   session,
   channel,
-  configurations,
-  initialPull = "",
-  disabled,
   writable,
   onEditingChange,
   onOpenThread,
   readPull = publicPullReader,
 }: {
   session: RelaySession;
-  readPull?: ReadPull;
   channel: string;
-  configurations: readonly SavedReviewConfig[];
-  initialPull?: string;
-  disabled: boolean;
   writable: boolean;
   onEditingChange: (editing: boolean) => void;
   onOpenThread?: ((channel: string, id: string) => Promise<void>) | undefined;
+  readPull?: ReadPull;
 }) {
-  const [rows, setRows] = useState<SavedSubmission[]>([]);
-  const [reload, setReload] = useState(0);
-  const [loading, setLoading] = useState(true);
+  const choices = useAgentChoices(session, true, true);
+  const [pr, setPr] = useState("");
+  const [busy, setBusy] = useState(false);
   const [error, setError] = useState("");
+  const [status, setStatus] = useState("");
+  const [result, setResult] = useState<SavedSubmission>();
+  const [rows, setRows] = useState<SavedSubmission[]>([]);
+  const input = useRef<HTMLInputElement>(null);
+  const [listLoading, setListLoading] = useState(true);
+  const [listError, setListError] = useState("");
   const [warning, setWarning] = useState("");
-  const [draft, setDraft] = useState<
-    | {
-        config: SavedReviewConfig;
-        existing?: SavedSubmission;
-      }
-    | undefined
-  >(() =>
-    initialPull && configurations[0]
-      ? { config: configurations[0] }
-      : undefined,
-  );
-  const trigger = useRef<HTMLButtonElement | null>(null);
+  const [reload, setReload] = useState(0);
+  const operation = useRef<AbortController | undefined>(undefined);
+  useEffect(() => () => operation.current?.abort(), []);
   useEffect(() => {
-    onEditingChange(!!draft);
-    if (!draft) trigger.current?.focus();
+    onEditingChange(busy || !!pr.trim());
     return () => onEditingChange(false);
-  }, [draft, onEditingChange]);
+  }, [busy, pr, onEditingChange]);
   // biome-ignore lint/correctness/useExhaustiveDependencies: Reload is an explicit fresh read.
   useEffect(() => {
     const controller = new AbortController();
-    setLoading(true);
-    setError("");
+    setListError("");
+    setListLoading(true);
     loadSubmissions(
       session,
       channel,
       AbortSignal.any([controller.signal, AbortSignal.timeout(20_000)]),
     )
-      .then((result) => {
-        if (!controller.signal.aborted) {
-          setRows(result.rows);
-          setWarning(result.warning);
-        }
+      .then((next) => {
+        if (controller.signal.aborted) return;
+        // A list read can finish after Submit; keep the action's newer result.
+        setRows((current) => [
+          ...current,
+          ...next.rows.filter(
+            (row) =>
+              !current.some((item) => item.artifactId === row.artifactId),
+          ),
+        ]);
+        setWarning(next.warning);
       })
       .catch((reason: unknown) => {
         if (!controller.signal.aborted)
-          setError(
+          setListError(
             reason instanceof Error
               ? reason.message
-              : "Could not load submissions.",
+              : "Could not load previous submissions.",
           );
       })
       .finally(() => {
-        if (!controller.signal.aborted) setLoading(false);
+        if (!controller.signal.aborted) setListLoading(false);
       });
     return () => controller.abort();
   }, [session, channel, reload]);
-  const visibleRows = rows.filter((row) =>
-    configurations.some(
-      (config) => config.config.repository === row.value.config.repository,
-    ),
-  );
-  return (
-    <section className="review-config-form" aria-label="PR submissions">
-      <div className="review-config-actions">
-        <Button
-          ref={trigger}
-          variant="prominent"
-          disabled={
-            disabled ||
-            loading ||
-            !!draft ||
-            !writable ||
-            !configurations.length
-          }
-          onClick={(event) => {
-            trigger.current = event.currentTarget;
-            const first = configurations[0];
-            if (first) setDraft({ config: first });
-          }}
-        >
-          Submit PR
-        </Button>
-      </div>
-      {draft && (
-        <SubmissionForm
-          key={draft.existing?.artifactId ?? "new"}
-          session={session}
-          channel={channel}
-          configurations={configurations}
-          initial={draft.config}
-          initialPull={initialPull}
-          readPull={readPull}
-          existing={draft.existing}
-          writable={writable && !loading && !error}
-          onClose={() => setDraft(undefined)}
-          onProgress={(record) =>
-            setRows((current) => [
-              record,
-              ...current.filter((row) => row.artifactId !== record.artifactId),
-            ])
-          }
-        />
-      )}
-      <section className="review-config-form" aria-label="Existing PRs">
-        <InlineHeader title="Existing PRs" />
-        <div>
-          <Button
-            disabled={disabled || !!draft || loading}
-            onClick={() => setReload((value) => value + 1)}
-          >
-            Reload submissions
-          </Button>
-        </div>
-        {loading && <p role="status">Loading submissions…</p>}
-        {error && (
-          <p role="alert">{error} Use Reload submissions to try again.</p>
-        )}
-        {warning && <p role="alert">{warning}</p>}
-        {!loading && !error && !visibleRows.length && (
-          <p>No PRs submitted for this repository.</p>
-        )}
-        <Accordion
-          variant="form"
-          items={visibleRows.map((row) => ({
-            value: row.artifactId,
-            title: (
-              <span className="review-config-pr-summary">
-                <span>
-                  {row.value.config.repository}#{row.value.pr}
-                </span>
-                <span className="text-caption text-subtle">
-                  {row.value.threads.every((thread) => thread.delivered)
-                    ? "Requests delivered"
-                    : "Delivery incomplete"}
-                </span>
-              </span>
-            ),
-            content: (
-              <section
-                className="review-config-lane"
-                aria-label={`${row.value.config.repository}#${row.value.pr}`}
-              >
-                <p>{prUrl(row.value)}</p>
-                {row.value.threads.map((thread, index) => (
-                  <div
-                    key={submissionLane(row.value, index)?.id ?? "overview"}
-                    className="review-config-actions"
-                  >
-                    <span>
-                      {submissionLane(row.value, index)?.name ??
-                        "Overview (earlier submission)"}
-                      :{" "}
-                      {thread.delivered
-                        ? "Request delivered"
-                        : thread.id || thread.started
-                          ? "Delivery unconfirmed"
-                          : "Not sent"}
-                    </span>
-                    {thread.id && (
-                      <Button
-                        disabled={!onOpenThread || !!draft || disabled}
-                        onClick={async () => {
-                          try {
-                            if (thread.id)
-                              await onOpenThread?.(channel, thread.id);
-                          } catch (reason) {
-                            setError(
-                              reason instanceof Error
-                                ? reason.message
-                                : "Could not open thread.",
-                            );
-                          }
-                        }}
-                      >
-                        Open{" "}
-                        {submissionLane(row.value, index)?.name ?? "overview"}{" "}
-                        thread
-                      </Button>
-                    )}
-                  </div>
-                ))}
-                {!row.value.threads.every((thread) => thread.delivered) && (
-                  <div>
-                    <Button
-                      disabled={disabled || loading || !!draft || !writable}
-                      onClick={(event) => {
-                        trigger.current = event.currentTarget;
-                        setDraft({
-                          config: {
-                            config: row.value.config,
-                            revision: row.value.configRevision,
-                            artifactId: "",
-                          },
-                          existing: row,
-                        });
-                      }}
-                    >
-                      Resume submission
-                    </Button>
-                  </div>
-                )}
-              </section>
-            ),
-          }))}
-        />
-      </section>
-    </section>
-  );
-}
 
-function SubmissionForm({
-  session,
-  channel,
-  configurations,
-  initial,
-  initialPull,
-  existing,
-  writable,
-  onClose,
-  onProgress,
-  readPull,
-}: {
-  session: RelaySession;
-  readPull: ReadPull;
-  channel: string;
-  configurations: readonly SavedReviewConfig[];
-  initial: SavedReviewConfig;
-  initialPull: string;
-  existing: SavedSubmission | undefined;
-  writable: boolean;
-  onClose: () => void;
-  onProgress: (record: SavedSubmission) => void;
-}) {
-  const choices = useAgentChoices(session, true, true);
-  const [config, setConfig] = useState(initial);
-  const [pr, setPr] = useState(
-    existing ? String(existing.value.pr) : initialPull,
-  );
-  const [reviewers, setReviewers] = useState(
-    initial.config.lanes.map((lane) => lane.reviewers[0] ?? ""),
-  );
-  const [facts, setFacts] = useState<PullFacts>();
-  const matched = useMemo(
-    () =>
-      config.config.lanes.map(
-        (lane) => !!facts && laneMatches(lane.routing, facts),
-      ),
-    [config.config.lanes, facts],
-  );
-  const [reading, setReading] = useState(false);
-  const [busy, setBusy] = useState(false);
-  const [error, setError] = useState("");
-  const [started, setStarted] = useState(!!existing);
-  const operation = useRef<AbortController | undefined>(undefined);
-  useEffect(() => () => operation.current?.abort(), []);
-  async function preview() {
-    if (operation.current) return;
-    const controller = new AbortController();
-    operation.current = controller;
-    setReading(true);
-    setFacts(undefined);
-    setError("");
-    try {
-      const next = await readPull(
-        config.config.repository,
-        pullRequest(pr, config.config.repository),
-        AbortSignal.any([controller.signal, AbortSignal.timeout(60_000)]),
-      );
-      if (!controller.signal.aborted) setFacts(next);
-    } catch (reason) {
-      if (!controller.signal.aborted)
-        setError(
-          reason instanceof Error ? reason.message : "Could not load PR.",
-        );
-    } finally {
-      operation.current = undefined;
-      if (!controller.signal.aborted) setReading(false);
-    }
-  }
   async function submit() {
     if (operation.current || !writable) return;
     const controller = new AbortController();
+    const signal = AbortSignal.any([
+      controller.signal,
+      AbortSignal.timeout(120_000),
+    ]);
     operation.current = controller;
     setBusy(true);
     setError("");
-    let recorded = started;
+    setResult(undefined);
+    setStatus("Finding repository and assigning reviewers…");
+    let existing = false;
+    let recorded = false;
+    let alreadyComplete: boolean | undefined;
     try {
-      if (!started) {
-        if (!facts)
-          throw new Error("Load PR details to preview matching lanes first.");
-        const current = await readPull(
-          config.config.repository,
-          pullRequest(pr, config.config.repository),
-          AbortSignal.any([controller.signal, AbortSignal.timeout(60_000)]),
-        );
-        if (pullFingerprint(current) !== pullFingerprint(facts)) {
-          setFacts(current);
+      const repository = pullRepository(pr);
+      const configurations = await loadConfigurations(session, channel, signal);
+      const saved = configurations.rows.find(
+        (row) => row.config.repository === repository,
+      );
+      if (!saved) {
+        if (configurations.truncated || configurations.unreadable)
           throw new Error(
-            "The PR changed. Review the updated matching lanes before starting threads.",
+            "Could not confirm this repository's configuration. Check Review Configuration and try again.",
           );
-        }
+        throw new Error(
+          `${repository} is not configured in this channel. Add it in Review Configuration, then submit again.`,
+        );
       }
-      await submitReview(
+      const record = await submitReview(
         session,
         channel,
-        config,
+        saved,
         pr,
-        reviewers,
-        AbortSignal.any([controller.signal, AbortSignal.timeout(120_000)]),
-        (record) => {
-          if (!controller.signal.aborted) {
-            recorded = true;
-            setStarted(true);
-            setConfig({
-              config: record.value.config,
-              revision: record.value.configRevision,
-              artifactId: config.artifactId,
-            });
-            setPr(String(record.value.pr));
-            setReviewers(
-              record.value.config.lanes.map((lane) => lane.reviewers[0] ?? ""),
-            );
-            onProgress(record);
-          }
+        saved.config.lanes.map((lane) => lane.reviewers[0] ?? ""),
+        signal,
+        (next) => {
+          if (controller.signal.aborted) return;
+          recorded = true;
+          alreadyComplete ??= next.value.threads.every(
+            (thread) => thread.delivered,
+          );
+          setResult(next);
+          setRows((current) => [
+            next,
+            ...current.filter((row) => row.artifactId !== next.artifactId),
+          ]);
         },
-        started,
-        facts,
+        true,
+        () => readPull(repository, pullRequest(pr, repository), signal),
+        () => {
+          existing = true;
+        },
+      );
+      if (controller.signal.aborted) return;
+      setResult(record);
+      setStatus(
+        existing && alreadyComplete
+          ? "Already exists — reviewers notified in their existing threads."
+          : "Submitted — reviewers assigned and requests delivered.",
       );
-      if (!controller.signal.aborted) onClose();
     } catch (reason) {
-      if (!controller.signal.aborted)
+      if (!controller.signal.aborted) {
+        setStatus("");
         setError(
-          `${reason instanceof Error ? reason.message : "Could not submit."} ${recorded ? "Saved messages are retained. Close and reload submissions to check progress; Resume retries the same messages." : "Your draft is still here."}`,
+          `${reason instanceof Error ? reason.message : "Could not submit PR."}${recorded ? " Existing threads are preserved. Submit again to retry unconfirmed delivery." : ""}`,
         );
+      }
     } finally {
       operation.current = undefined;
       if (!controller.signal.aborted) setBusy(false);
     }
   }
+
+  function threads(row: SavedSubmission) {
+    return (
+      <section
+        className="review-config-form"
+        aria-label={`${row.value.config.repository}#${row.value.pr} reviewers`}
+      >
+        {row.value.threads.map((thread, index) => {
+          const lane = submissionLane(row.value, index);
+          return (
+            <div
+              key={lane?.id ?? "overview"}
+              className="review-config-actions review-config-result-row"
+            >
+              <span className="text-caption text-subtle">
+                {lane?.name ?? "Overview (earlier submission)"}
+              </span>
+              {lane?.reviewers.map((pubkey) => (
+                <ReviewerIdentity
+                  key={pubkey}
+                  pubkey={pubkey}
+                  choices={choices}
+                />
+              ))}
+              <div className="review-config-actions">
+                {thread.id ? (
+                  <Button
+                    disabled={busy || !onOpenThread}
+                    onClick={async () => {
+                      try {
+                        if (thread.id) await onOpenThread?.(channel, thread.id);
+                      } catch (reason) {
+                        setError(
+                          reason instanceof Error
+                            ? reason.message
+                            : "Could not open thread.",
+                        );
+                      }
+                    }}
+                  >
+                    Open {lane?.name ?? "overview"} thread
+                  </Button>
+                ) : (
+                  <span>Thread delivery pending</span>
+                )}
+                {!thread.delivered && thread.id && (
+                  <span>Delivery unconfirmed</span>
+                )}
+              </div>
+            </div>
+          );
+        })}
+      </section>
+    );
+  }
+
   return (
-    <form
-      className="review-config-form"
-      onSubmit={(event) => {
-        event.preventDefault();
-        void submit();
-      }}
-    >
-      <InlineHeader
-        title={started ? "Resume saved submission" : "New PR submission"}
-      />
-      <SettingsGroup layout="form">
-        {configurations.length > 1 && (
-          <Select
-            label="Repository to review"
-            variant="field"
-            value={config.config.repository}
-            disabled={busy || reading || started}
-            groups={[
-              {
-                label: "Repositories",
-                options: (existing ? [config] : configurations).map((row) => ({
-                  value: row.config.repository,
-                  label: row.config.repository,
-                })),
-              },
-            ]}
-            onValueChange={(repository) => {
-              const row = configurations.find(
-                (item) => item.config.repository === repository,
-              );
-              if (row) {
-                setFacts(undefined);
-                setConfig(row);
-                setReviewers(
-                  row.config.lanes.map((lane) => lane.reviewers[0] ?? ""),
-                );
-              }
-            }}
-          />
-        )}
+    <section className="review-config-form" aria-label="PR submissions">
+      <form
+        className="review-config-form"
+        onSubmit={(event) => {
+          event.preventDefault();
+          void submit();
+        }}
+      >
         <Field
-          label="Pull request"
-          description="Enter a PR number or full GitHub PR URL, then load its details to preview matching lanes."
+          label="GitHub PR URL"
+          description="We’ll assign a reviewer to each matching lane. Submitting an existing PR notifies its reviewers again."
         >
           <Input
-            autoFocus
+            ref={input}
             required
             maxLength={300}
-            placeholder="https://github.com/example-org/project/pull/123"
             value={pr}
-            disabled={busy || reading || started}
+            disabled={busy}
+            placeholder="https://github.com/example-org/project/pull/123"
+            autoCapitalize="none"
+            autoCorrect="off"
+            spellCheck={false}
             onValueChange={(value) => {
               setPr(value);
-              setFacts(undefined);
+              setError("");
+              setStatus("");
+              setResult(undefined);
             }}
           />
         </Field>
-      </SettingsGroup>
-      {!started && (
-        <div className="review-config-form">
-          <div>
-            <Button
-              disabled={busy || reading || !pr.trim()}
-              loading={reading}
-              onClick={() => void preview()}
-            >
-              Load PR details
-            </Button>
-          </div>
-          {facts && (
-            <>
-              <p>
-                {facts.title} · {facts.changedFiles} changed files · Labels:{" "}
-                {facts.labels.join(", ") || "none"}
-              </p>
-              <p>
-                Matching lanes:{" "}
-                {config.config.lanes
-                  .filter((_, index) => matched[index])
-                  .map((lane) => lane.name)
-                  .join(", ") ||
-                  "None. Adjust the lane rules before submitting."}
-              </p>
-              <p>
-                Other lanes:{" "}
-                {config.config.lanes
-                  .filter((_, index) => !matched[index])
-                  .map((lane) => lane.name)
-                  .join(", ") || "none"}
-              </p>
-            </>
-          )}
+        <div>
+          <Button
+            type="submit"
+            variant="prominent"
+            loading={busy}
+            disabled={!writable || !pr.trim()}
+          >
+            Submit PR
+          </Button>
         </div>
-      )}
-      {config.config.lanes.map((lane, index) =>
-        !started && !matched[index] ? null : (
-          <section key={lane.id} className="review-config-lane">
-            <Select
-              variant="field"
-              label={`${lane.name} reviewer`}
-              value={reviewers[index] ?? ""}
-              required
-              disabled={busy || reading || started}
-              placeholder="Choose a reviewer"
-              groups={[
-                {
-                  label: "Configured reviewers",
-                  options: lane.reviewers.map((key) => {
-                    const choice = choices.selectable.find(
-                      (item) => item.pubkey === key,
-                    );
-                    return {
-                      value: key,
-                      label:
-                        choice?.managedName ??
-                        choice?.name ??
-                        `Unavailable (${key.slice(0, 10)})`,
-                      disabled: !choice,
-                    };
-                  }),
-                },
-              ]}
-              onValueChange={(value) =>
-                setReviewers((current) =>
-                  current.map((item, i) => (i === index ? value : item)),
-                )
-              }
-            />
-            <details>
-              <summary>Instructions for {lane.name}</summary>
-              <p className="review-config-instructions">{lane.instructions}</p>
-            </details>
-          </section>
-        ),
-      )}
-      <p>
-        This sends a request to one reviewer per matching lane in this channel,
-        with no extra overview thread. Reviewers must belong to your signed-in
-        identity and already have channel access. Their model runner must be
-        connected to reply.
-      </p>
+      </form>
       {error && <p role="alert">{error}</p>}
-      {busy && <p role="status">Saving submission and delivering threads…</p>}
-      <div className="review-config-actions">
-        <Button disabled={busy || reading} onClick={onClose}>
-          {started ? "Close" : "Cancel"}
-        </Button>
-        <Button
-          type="submit"
-          variant="prominent"
-          loading={busy}
-          disabled={
-            !writable ||
-            choices.pending ||
-            reading ||
-            (!started && (!facts || !matched.some(Boolean)))
-          }
+      {status && <p role="status">{status}</p>}
+      {result && (
+        <section className="review-config-form" aria-label="Submission result">
+          <InlineHeader
+            title={`${result.value.config.repository}#${result.value.pr}`}
+          />
+          {threads(result)}
+        </section>
+      )}
+      <section className="review-config-form" aria-label="Existing PRs">
+        <InlineHeader title="Existing PRs" />
+        <LoadingRegion
+          pending={listLoading}
+          label="Loading submissions…"
+          statusVisibility="screen-reader"
         >
-          {started ? "Resume delivery" : "Start review threads"}
-        </Button>
-      </div>
-    </form>
+          {!listLoading && !listError && !rows.length && (
+            <p>No PRs submitted in this channel yet.</p>
+          )}
+        </LoadingRegion>
+        {listError && (
+          <>
+            <p role="alert">{listError}</p>
+            <div>
+              <Button
+                disabled={busy}
+                onClick={() => setReload((value) => value + 1)}
+              >
+                Reload submissions
+              </Button>
+            </div>
+          </>
+        )}
+        {warning && <p role="alert">{warning}</p>}
+        <Accordion
+          variant="form"
+          items={rows
+            .filter((row) => row.artifactId !== result?.artifactId)
+            .map((row) => ({
+              value: row.artifactId,
+              title: (
+                <span className="review-config-pr-summary">
+                  <span>
+                    {row.value.config.repository}#{row.value.pr}
+                  </span>
+                  <span className="text-caption text-subtle">
+                    {row.value.threads.every((thread) => thread.delivered)
+                      ? "Requests delivered"
+                      : "Delivery incomplete"}
+                  </span>
+                </span>
+              ),
+              content: (
+                <div className="review-config-form">
+                  {threads(row)}
+                  <div>
+                    <Button
+                      disabled={busy}
+                      onClick={() => {
+                        setPr(prUrl(row.value));
+                        input.current?.focus();
+                        setResult(row);
+                        setError("");
+                        setStatus(
+                          "Submit again to notify reviewers or resume incomplete delivery.",
+                        );
+                      }}
+                    >
+                      Use this PR
+                    </Button>
+                  </div>
+                </div>
+              ),
+            }))}
+        />
+      </section>
+    </section>
   );
 }
diff --git a/src/bundled/review-configuration/index.tsx b/src/bundled/review-configuration/index.tsx
index 9bfd296376..a76efb3979 100644
--- a/src/bundled/review-configuration/index.tsx
+++ b/src/bundled/review-configuration/index.tsx
@@ -7,18 +7,20 @@ export const inject = ["pages", "relay", "navigation", "host"];
 export const apply: PluginModule["apply"] = (ctx) => {
   const { relay, navigation: navigator } = ctx;
   const readPull = createPullReader(gitHubCli(ctx.host));
-  ctx.pages.register({
-    id: "configuration",
-    title: "Review Configuration",
-    layout: "workspace",
-    primary: true,
-    placement: "sidebar",
-    component: () => (
-      <ReviewConfigurationPage
-        relay={relay}
-        navigator={navigator}
-        readPull={readPull}
-      />
-    ),
-  });
+  for (const submit of [false, true])
+    ctx.pages.register({
+      id: submit ? "submit" : "configuration",
+      title: submit ? "Submit PR" : "Review Configuration",
+      layout: "workspace",
+      primary: true,
+      placement: "sidebar",
+      component: () => (
+        <ReviewConfigurationPage
+          submit={submit}
+          relay={relay}
+          navigator={navigator}
+          readPull={readPull}
+        />
+      ),
+    });
 };
diff --git a/src/bundled/review-configuration/manifest.json b/src/bundled/review-configuration/manifest.json
index 5725d4bd68..c4649e4f05 100644
--- a/src/bundled/review-configuration/manifest.json
+++ b/src/bundled/review-configuration/manifest.json
@@ -2,7 +2,7 @@
   "id": "buzz.review-configuration",
   "name": "Review Configuration",
   "apiVersion": 1,
-  "description": "Save repository and lane settings for review workflows.",
+  "description": "Configure review lanes and submit PRs to assigned reviewers.",
   "discovery": {
     "category": "productivity",
     "tags": ["code", "tasks"]
diff --git a/src/bundled/review-configuration/review-configuration.css b/src/bundled/review-configuration/review-configuration.css
index a849ebea7b..bb90f119f5 100644
--- a/src/bundled/review-configuration/review-configuration.css
+++ b/src/bundled/review-configuration/review-configuration.css
@@ -102,3 +102,7 @@
   margin: 0;
   padding-inline-start: var(--space-5);
 }
+
+.review-config-result-row {
+  align-items: center;
+}
diff --git a/src/bundled/review-configuration/submissions.test.ts b/src/bundled/review-configuration/submissions.test.ts
index f5e55c8b1c..a931830b6c 100644
--- a/src/bundled/review-configuration/submissions.test.ts
+++ b/src/bundled/review-configuration/submissions.test.ts
@@ -492,3 +492,155 @@ it("infers a canonical repository only from a valid full PR URL", () => {
   ])
     expect(() => pullRepository(input)).toThrow();
 });
+
+it("explicit resubmission notifies saved reviewers in existing threads without new artifacts or GitHub reads", async () => {
+  const test = await fixture();
+  const first = await test.run();
+  const writes = test.artifactPublish.mock.calls.length;
+  const facts = vi.fn(async () => {
+    throw new Error("GitHub unavailable");
+  });
+  const existing = vi.fn();
+  const again = () =>
+    submitReview(
+      test.session,
+      channel,
+      test.config,
+      "123",
+      [test.agent.pubkey, test.agent.pubkey],
+      new AbortController().signal,
+      () => {},
+      true,
+      facts,
+      existing,
+    );
+  const result = await again();
+  expect(result.value.threads).toEqual(first.value.threads);
+  expect(test.artifactPublish).toHaveBeenCalledTimes(writes);
+  expect(facts).not.toHaveBeenCalled();
+  expect(existing).toHaveBeenCalledOnce();
+  const replies = [...test.messages.values()].filter((event) =>
+    event.tags.some((tag) => tag[0] === "e"),
+  );
+  expect(replies).toHaveLength(2);
+  for (const [i, reply] of replies.entries()) {
+    expect(reply.tags).toContainEqual([
+      "e",
+      first.value.threads[i]?.id,
+      "",
+      "reply",
+    ]);
+    expect(reply.tags).toContainEqual(["p", test.agent.pubkey]);
+    expect(reply.tags.some((tag) => tag[0] === "subject")).toBe(false);
+    expect(reply.content).toContain("submitted again");
+  }
+  await again();
+  expect(test.publish).toHaveBeenCalledTimes(6);
+});
+
+it("revalidates ownership before notifying and retains existing threads on refusal", async () => {
+  const test = await fixture();
+  await test.run();
+  test.changeOwner();
+  await expect(
+    submitReview(
+      test.session,
+      channel,
+      test.config,
+      "123",
+      [test.agent.pubkey, test.agent.pubkey],
+      new AbortController().signal,
+      () => {},
+      true,
+      undefined,
+      () => {},
+    ),
+  ).rejects.toThrow("verified ownership");
+  expect(test.publish).toHaveBeenCalledTimes(2);
+});
+
+it("routes fresh facts inside Submit and refuses no-match before writing", async () => {
+  const test = await fixture();
+  const config = {
+    ...test.config,
+    config: {
+      ...test.config.config,
+      lanes: test.config.config.lanes.map((lane) => ({
+        ...lane,
+        routing: {
+          mode: "all" as const,
+          rules: [
+            {
+              id: "label",
+              field: "label" as const,
+              operator: "has" as const,
+              value: "security",
+            },
+          ],
+        },
+      })),
+    },
+  };
+  const facts = vi.fn(async () => ({
+    repository: "example-org/project",
+    pr: 123,
+    title: "UI change",
+    labels: [],
+    changedFiles: 1,
+    paths: ["ui.tsx"],
+    head: "a".repeat(40),
+    base: "b".repeat(40),
+  }));
+  await expect(
+    submitReview(
+      test.session,
+      channel,
+      config,
+      "123",
+      [test.agent.pubkey, test.agent.pubkey],
+      new AbortController().signal,
+      () => {},
+      true,
+      facts,
+      () => {},
+    ),
+  ).rejects.toThrow("No lanes match");
+  expect(facts).toHaveBeenCalledOnce();
+  expect(test.artifactPublish).not.toHaveBeenCalled();
+  expect(test.publish).not.toHaveBeenCalled();
+});
+
+it("retries a partially delivered notification batch with the same message identities", async () => {
+  const test = await fixture();
+  const first = await test.run();
+  test.publish.mockImplementationOnce(async (event) => {
+    test.messages.set(event.id, event);
+  });
+  test.publish.mockRejectedValueOnce(new Error("notification offline"));
+  const again = () =>
+    submitReview(
+      test.session,
+      channel,
+      test.config,
+      "123",
+      [test.agent.pubkey, test.agent.pubkey],
+      new AbortController().signal,
+      () => {},
+      true,
+      undefined,
+      () => {},
+    );
+  await expect(again()).rejects.toThrow("notification offline");
+  const attempted = test.publish.mock.calls.slice(2).map(([event]) => event.id);
+  await again();
+  expect(test.publish.mock.calls.slice(2).map(([event]) => event.id)).toEqual([
+    ...attempted,
+    attempted[1],
+  ]);
+  expect(
+    [...test.messages.values()].filter((event) =>
+      event.tags.some((tag) => tag[0] === "subject"),
+    ),
+  ).toHaveLength(2);
+  expect((await test.run()).value.threads).toEqual(first.value.threads);
+});
diff --git a/src/bundled/review-configuration/submissions.ts b/src/bundled/review-configuration/submissions.ts
index 753bee17bb..d6306f1583 100644
--- a/src/bundled/review-configuration/submissions.ts
+++ b/src/bundled/review-configuration/submissions.ts
@@ -306,6 +306,62 @@ function delivered(
   });
 }
 
+/** Explicit resubmission mentions the saved reviewer in each existing lane thread.
+ * Keep receipts until the whole batch succeeds so interrupted sends can resume. */
+async function notifyReviewers(
+  session: RelaySession,
+  channel: string,
+  record: SavedSubmission,
+  signal: AbortSignal,
+) {
+  const outbox = session.outbox;
+  if (!outbox) throw new Error("Message delivery is unavailable.");
+  await eligible(session, record.value, signal);
+  const receipts: string[] = [];
+  for (const [index, thread] of record.value.threads.entries()) {
+    const lane = submissionLane(record.value, index);
+    if (!lane || !thread.id) continue; // Older submissions also have an overview.
+    signal.throwIfAborted();
+    const key = `review-notify:${record.artifactId}:${thread.id}`;
+    const recovery = await outbox.recovery(key);
+    const active = () => !signal.aborted;
+    let id: string;
+    if (recovery) {
+      id = recovery.event.id;
+      if (!outbox.snapshot().some((item) => item.event.id === id))
+        throw new Error("Reload to recover the saved reviewer notification.");
+      if (!["accepted", "seen", "sending"].includes(recovery.delivery))
+        outbox.retry(id, active);
+    } else {
+      const request = threadMessage(
+        record.value,
+        channel,
+        index,
+        session.agentChoices
+          .snapshot()
+          .selectable.find((choice) => choice.pubkey === lane.reviewers[0])
+          ?.name,
+      );
+      id = outbox.send(
+        {
+          kind: 9,
+          tags: [
+            ["h", channel],
+            ["e", thread.id, "", "reply"],
+            ["p", lane.reviewers[0] ?? ""],
+          ],
+          content: `This PR was submitted again. Please revisit the review in this thread.\n\n${request.content}`,
+        },
+        { key, value: record.artifactId },
+        active,
+      );
+    }
+    await delivered(outbox, id, signal);
+    receipts.push(id);
+  }
+  for (const id of receipts) await outbox.acknowledge(id);
+}
+
 /** Explicit user action only. There is no background dispatcher or polling. */
 export async function submitReview(
   session: RelaySession,
@@ -316,7 +372,8 @@ export async function submitReview(
   signal: AbortSignal,
   onProgress: (value: SavedSubmission) => void,
   resume = false,
-  facts?: PullFacts,
+  facts?: PullFacts | (() => Promise<PullFacts>),
+  notifyExisting?: () => void,
 ) {
   const outbox = session.outbox;
   const read = session.snapshotRead;
@@ -348,20 +405,28 @@ export async function submitReview(
       );
       let record: SavedSubmission;
       const head = events[0];
-      if (head) record = await decode(head, channel);
-      else {
+      if (head) {
+        record = await decode(head, channel);
+        notifyExisting?.();
+      } else {
+        const currentFacts =
+          typeof facts === "function" ? await facts() : facts;
+        signal.throwIfAborted();
         if (
-          facts &&
-          (facts.repository !== saved.config.repository || facts.pr !== pr)
+          currentFacts &&
+          (currentFacts.repository !== saved.config.repository ||
+            currentFacts.pr !== pr)
         )
           throw new Error("The loaded PR does not match this submission.");
         if (
-          !facts &&
+          !currentFacts &&
           saved.config.lanes.some((lane) => lane.routing?.rules.length)
         )
           throw new Error("Load PR details before routing this submission.");
         const matched = saved.config.lanes.flatMap((lane, i) =>
-          !facts || laneMatches(lane.routing, facts) ? [{ lane, i }] : [],
+          !currentFacts || laneMatches(lane.routing, currentFacts)
+            ? [{ lane, i }]
+            : [],
         );
         if (!matched.length)
           throw new Error(
@@ -389,9 +454,11 @@ export async function submitReview(
         record = await write(session, channel, value, undefined, signal);
       }
       onProgress(record);
-      // A duplicate opens the saved preview; only explicit Resume can dispatch it.
-      if (head && !resume) return record;
+      // The dedicated Submit action may notify; passive readers never dispatch.
+      if (head && !resume && !notifyExisting) return record;
       if (record.value.threads.every((thread) => thread.delivered)) {
+        if (head && notifyExisting)
+          await notifyReviewers(session, channel, record, signal);
         for (const thread of record.value.threads)
           if (thread.id) await outbox.acknowledge(thread.id);
         return record;

From 94846c03f1dee94674b5d25db33d0f879487ccdf Mon Sep 17 00:00:00 2001
From: Ravneet Arora <rarora@squareup.com>
Date: Thu, 12 Nov 2026 13:58:33 -0500
Subject: [PATCH 08/17] test(review): cover separate submission page
 registration

Co-authored-by: maincourse <37ce551b493d4a998caf030929c47bce0b6a0e43f1178b3a63c4151d7c16b76e@buzz.block.builderlab.xyz>
Signed-off-by: Ravneet Arora <rarora@squareup.com>
---
 src/app/pages.integration.test.mjs                    | 11 +++++++++++
 .../review-configuration/ReviewConfigurationPage.tsx  |  4 +++-
 2 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/src/app/pages.integration.test.mjs b/src/app/pages.integration.test.mjs
index 4a218b5b7c..a1cb0a925a 100644
--- a/src/app/pages.integration.test.mjs
+++ b/src/app/pages.integration.test.mjs
@@ -130,6 +130,17 @@ test("the app runtime exposes ready bundled pages and removes them on disable",
       renderToStaticMarkup(createElement(reviewConfiguration.component)),
       /Connect to a community to configure reviews/,
     );
+    const submitPr = services.pages
+      .snapshot()
+      .find((page) => page.key === "buzz.review-configuration/submit");
+    assert.ok(submitPr);
+    assert.equal(submitPr.title, "Submit PR");
+    assert.equal(submitPr.primary, true);
+    assert.equal(submitPr.placement, "sidebar");
+    assert.match(
+      renderToStaticMarkup(createElement(submitPr.component)),
+      /Connect to a community to submit PRs/,
+    );
     await services.plugins.change("disable", "buzz.review-configuration");
     assert.equal(
       services.pages
diff --git a/src/bundled/review-configuration/ReviewConfigurationPage.tsx b/src/bundled/review-configuration/ReviewConfigurationPage.tsx
index e3e6ad3ec9..5fd3ab882f 100644
--- a/src/bundled/review-configuration/ReviewConfigurationPage.tsx
+++ b/src/bundled/review-configuration/ReviewConfigurationPage.tsx
@@ -100,7 +100,9 @@ export function ReviewConfigurationPage({
       <p>
         {connection.status === "connecting"
           ? "Connecting to your community…"
-          : "Connect to a community to use reviews."}
+          : submit
+            ? "Connect to a community to submit PRs."
+            : "Connect to a community to configure reviews."}
       </p>
       {connection.status === "error" && (
         <>

From 53c76b8619497c7a3e7b13dd51d998a608c2e987 Mon Sep 17 00:00:00 2001
From: Ravneet Arora <rarora@squareup.com>
Date: Thu, 12 Nov 2026 15:01:28 -0500
Subject: [PATCH 09/17] feat(review): separate PR table and submission actions

Co-authored-by: maincourse <37ce551b493d4a998caf030929c47bce0b6a0e43f1178b3a63c4151d7c16b76e@buzz.block.builderlab.xyz>
Signed-off-by: Ravneet Arora <rarora@squareup.com>
---
 docs/buzz-help.md                             |   8 +-
 src/app/pages.integration.test.mjs            |   8 +-
 src/bundled/review-configuration/README.md    |  10 +-
 .../ReviewConfigurationPage.test.tsx          |  30 +-
 .../ReviewConfigurationPage.tsx               |  97 +++-
 .../ReviewSubmissions.test.tsx                | 117 ++++-
 .../ReviewSubmissions.tsx                     | 416 +++++++++++-------
 src/bundled/review-configuration/index.tsx    |  16 +-
 .../review-configuration.css                  |  40 ++
 .../review-configuration/submissions.test.ts  |  50 +++
 .../review-configuration/submissions.ts       |  66 ++-
 11 files changed, 656 insertions(+), 202 deletions(-)

diff --git a/docs/buzz-help.md b/docs/buzz-help.md
index 5ac2276032..9e91cf1b75 100644
--- a/docs/buzz-help.md
+++ b/docs/buzz-help.md
@@ -1161,21 +1161,21 @@ confirmation. **Delete team** asks first; it doesn't delete the team's agents.
   reads the latest saved versions. Settings live on the community relay and are
   visible to channel readers; members who can post can edit them. A conflicting
   edit preserves your draft: copy your changes before cancelling and reloading.
-  **Review Configuration** contains repository and lane settings only. **Edit lane**
+  **Review Configuration** has repository and lane settings plus **Submit PR** and **All PRs** buttons that open separate pages. **Edit lane**
   opens one lane; **Save lane** persists it before **Add lane** starts another.
   **Back to lanes** cancels the editor; **Back to repositories** returns to the list.
   Every new or edited lane requires at least one all/any routing rule matching
   title text, labels, changed-file counts, or paths such as `src/**/*.tsx`.
   Earlier rule-free lanes still match every PR until edited.
-  The separate **Submit PR** sidebar page has a full GitHub PR URL field and a
+  The **Submit PR** page has a full GitHub PR URL field and a
   Submit button. It finds the repository in the selected review channel, reads
   current PR details, and assigns the first configured reviewer in each matching
   lane. Missing configuration or zero matching lanes sends nothing. Results show
-  assigned agents and their thread buttons; **Existing PRs** lists previous submissions.
+  assigned agents and their thread buttons. **All PRs** shows previous submissions in a bordered table. The original submitter can confirm **Delete** to remove a submission from the shared list; its conversations and GitHub PR remain. Deleting does not stop active reviews. Resubmitting restores its saved reviewers and threads.
   Submitting an existing PR reuses its saved reviewers and threads and mentions
   them again in those threads. Incomplete initial delivery resumes from the original
   browser profile. An interrupted notification retries its saved messages.
-  No configuration controls appear on Submit PR. Both pages remember the selected
+  No configuration controls appear on Submit PR or All PRs. Both have a Back button. All pages remember the selected
   review channel. Reviewers must be owned by the signed-in identity and already
   belong to the channel. A connected agent runtime is needed for replies;
   delivery alone does not mean a review started. Desktop uses signed-in GitHub
diff --git a/src/app/pages.integration.test.mjs b/src/app/pages.integration.test.mjs
index a1cb0a925a..a35ba5cc44 100644
--- a/src/app/pages.integration.test.mjs
+++ b/src/app/pages.integration.test.mjs
@@ -135,12 +135,18 @@ test("the app runtime exposes ready bundled pages and removes them on disable",
       .find((page) => page.key === "buzz.review-configuration/submit");
     assert.ok(submitPr);
     assert.equal(submitPr.title, "Submit PR");
-    assert.equal(submitPr.primary, true);
+    assert.equal(submitPr.primary, false);
     assert.equal(submitPr.placement, "sidebar");
     assert.match(
       renderToStaticMarkup(createElement(submitPr.component)),
       /Connect to a community to submit PRs/,
     );
+    const allPrs = services.pages
+      .snapshot()
+      .find((page) => page.key === "buzz.review-configuration/all");
+    assert.ok(allPrs);
+    assert.equal(allPrs.title, "All PRs");
+    assert.equal(allPrs.primary, false);
     await services.plugins.change("disable", "buzz.review-configuration");
     assert.equal(
       services.pages
diff --git a/src/bundled/review-configuration/README.md b/src/bundled/review-configuration/README.md
index 1d1cd14dfd..f25fa450a5 100644
--- a/src/bundled/review-configuration/README.md
+++ b/src/bundled/review-configuration/README.md
@@ -6,14 +6,14 @@ Choose a channel, register a GitHub repository, add named lanes, reviewer agents
 and save. Open a repository row to manage its lanes. Saved cards show agents,
 instructions, and routing rules. **Edit lane** opens one lane; **Save lane** persists
 it before another can be added. **Back to lanes** cancels edits; **Back to repositories**
-returns to the list. Configuration contains no PR submission controls.
+returns to the list. The main page has **Submit PR** and **All PRs** buttons that open separate pages.
 
-The separate **Submit PR** sidebar page has a full GitHub PR URL field and one
+The **Submit PR** page has a full GitHub PR URL field and one
 Submit button. It finds the saved repository in the selected channel, loads current
 PR metadata, and assigns the first configured reviewer per matching lane. Missing
 configuration, unavailable reviewers, and zero matching lanes produce an error
 without starting threads. Results show assigned reviewers and thread buttons.
-Existing PRs are listed below, with optional details collapsed.
+**All PRs** shows previous submissions in a bordered table with delivery status, reviewer identities, and thread links. The submitter can confirm **Delete** to remove a submission from the shared list. This preserves its thread mapping and does not stop active reviews, delete conversations, or close the GitHub PR. Submitting that URL again restores the saved assignment and threads.
 
 Submitting an already-delivered PR sends a reviewer mention in each saved lane
 thread. It preserves the saved reviewers and instructions and creates no new
@@ -21,10 +21,10 @@ threads or review rounds. Incomplete original submissions resume delivery from
 the original browser profile instead. These actions run only on Submit; opening
 the page or a thread never dispatches messages.
 
-Both sidebar pages use the shell's page navigation. Repository and lane editing
+All three pages use the shell's page navigation. Only Review Configuration appears in the sidebar; Submit PR and All PRs have buttons back to it. Repository and lane editing
 remain local sections; reloading returns Configuration to its repository list.
 The channel selection is remembered per identity/community; one eligible channel
-is selected automatically. Submit results can be recovered from Existing PRs
+is selected automatically. Submit results can be recovered from All PRs
 following reload; navigation never replays Submit automatically.
 
 ## Getting started
diff --git a/src/bundled/review-configuration/ReviewConfigurationPage.test.tsx b/src/bundled/review-configuration/ReviewConfigurationPage.test.tsx
index 67599dabe4..65473c3862 100644
--- a/src/bundled/review-configuration/ReviewConfigurationPage.test.tsx
+++ b/src/bundled/review-configuration/ReviewConfigurationPage.test.tsx
@@ -483,14 +483,23 @@ it("preserves the remembered channel until pending metadata finishes", async ()
   );
 });
 
-it("keeps submission controls out of configuration and preserves lane drafts", async () => {
+it("opens dedicated pages from configuration and blocks leaving lane drafts", async () => {
   const test = fixture();
-  render(<ReviewConfigurationCommunity session={test.session} />);
+  const onNavigate = vi.fn(async () => {});
+  render(
+    <ReviewConfigurationCommunity
+      session={test.session}
+      onNavigate={onNavigate}
+    />,
+  );
   const user = await openDraft();
   await user.click(screen.getByRole("button", { name: "Save lane" }));
   await screen.findByText("Saved example-org/project.");
   expect(screen.queryByRole("region", { name: "PR submissions" })).toBeNull();
-  expect(screen.queryByRole("button", { name: "Submit PR" })).toBeNull();
+  await user.click(screen.getByRole("button", { name: "Submit PR" }));
+  expect(onNavigate).toHaveBeenCalledWith("submit");
+  await user.click(screen.getByRole("button", { name: "All PRs" }));
+  expect(onNavigate).toHaveBeenCalledWith("all");
   await user.click(screen.getByRole("button", { name: "Edit General lane" }));
   expect(
     screen.queryByRole("button", { name: "Back to repositories" }),
@@ -498,12 +507,23 @@ it("keeps submission controls out of configuration and preserves lane drafts", a
   const field = screen.getByRole("textbox", { name: "Instructions" });
   await user.clear(field);
   await user.type(field, "Preserve draft");
+  expect(
+    (screen.getByRole("button", { name: "Submit PR" }) as HTMLButtonElement)
+      .disabled,
+  ).toBe(true);
+  expect(
+    (screen.getByRole("button", { name: "All PRs" }) as HTMLButtonElement)
+      .disabled,
+  ).toBe(true);
   expect((field as HTMLTextAreaElement).value).toBe("Preserve draft");
   await user.click(screen.getByRole("button", { name: "Cancel" }));
   await user.click(
     screen.getByRole("button", { name: "Back to repositories" }),
   );
-  expect(screen.queryByRole("button", { name: "Submit PR" })).toBeNull();
+  await user.click(screen.getByRole("button", { name: "Submit PR" }));
+  expect(onNavigate).toHaveBeenCalledWith("submit");
+  await user.click(screen.getByRole("button", { name: "All PRs" }));
+  expect(onNavigate).toHaveBeenCalledWith("all");
   await user.click(
     screen.getByRole("button", { name: "Open example-org/project" }),
   );
@@ -549,7 +569,7 @@ it("blocks editor entry while a reload can replace the repository", async () =>
 
 it("opens the separate submit page without repository or lane configuration", async () => {
   const test = fixture();
-  render(<ReviewConfigurationCommunity session={test.session} submit />);
+  render(<ReviewConfigurationCommunity session={test.session} page="submit" />);
   await screen.findByRole("textbox", { name: "GitHub PR URL" });
   expect(screen.getByRole("button", { name: "Submit PR" })).toBeTruthy();
   expect(
diff --git a/src/bundled/review-configuration/ReviewConfigurationPage.tsx b/src/bundled/review-configuration/ReviewConfigurationPage.tsx
index 5fd3ab882f..768cdf3781 100644
--- a/src/bundled/review-configuration/ReviewConfigurationPage.tsx
+++ b/src/bundled/review-configuration/ReviewConfigurationPage.tsx
@@ -37,14 +37,22 @@ import {
 } from "./configuration";
 import "./review-configuration.css";
 
+export type ReviewPage = "configuration" | "submit" | "all";
+export const reviewPageTitle = (page: ReviewPage) =>
+  page === "submit"
+    ? "Submit PR"
+    : page === "all"
+      ? "All PRs"
+      : "Review Configuration";
+
 function Frame({
   children,
-  submit = false,
+  page = "configuration",
 }: {
   children: ReactNode;
-  submit?: boolean;
+  page?: ReviewPage;
 }) {
-  const title = submit ? "Submit PR" : "Review Configuration";
+  const title = reviewPageTitle(page);
   return (
     <FullPageSurface aria-label={title}>
       <div className="review-config-page text-body">
@@ -52,7 +60,9 @@ function Frame({
           title={<PanelHeaderLabel title={title} icon={<ListChecksIcon />} />}
         />
         <div className="review-config-scroll">
-          <div className="review-config-content">{children}</div>
+          <div className="review-config-content" data-review-page={page}>
+            {children}
+          </div>
         </div>
       </div>
     </FullPageSurface>
@@ -63,9 +73,9 @@ export function ReviewConfigurationPage({
   relay,
   navigator,
   readPull = publicPullReader,
-  submit = false,
+  page = "configuration",
 }: {
-  submit?: boolean;
+  page?: ReviewPage;
   relay: RelayData;
   navigator?: Navigation;
   readPull?: ReadPull;
@@ -76,8 +86,22 @@ export function ReviewConfigurationPage({
       <ReviewConfigurationCommunity
         key={`${connection.scope}:${connection.generation}`}
         session={connection.session}
-        submit={submit}
+        page={page}
         readPull={readPull}
+        onNavigate={
+          navigator
+            ? async (page) => {
+                const result = await navigator.open({
+                  version: 1,
+                  kind: "page",
+                  pluginId: "buzz.review-configuration",
+                  pageId: page,
+                });
+                if (result.status === "failed")
+                  throw new Error("Could not open review page.");
+              }
+            : undefined
+        }
         onOpenThread={async (channelId, id) => {
           const scope = splitPartition(connection.scope ?? "");
           if (!navigator || !scope)
@@ -96,11 +120,11 @@ export function ReviewConfigurationPage({
       />
     );
   return (
-    <Frame submit={submit}>
+    <Frame page={page}>
       <p>
         {connection.status === "connecting"
           ? "Connecting to your community…"
-          : submit
+          : page !== "configuration"
             ? "Connect to a community to submit PRs."
             : "Connect to a community to configure reviews."}
       </p>
@@ -117,12 +141,14 @@ export function ReviewConfigurationPage({
 export function ReviewConfigurationCommunity({
   session,
   onOpenThread,
+  onNavigate,
   readPull = publicPullReader,
-  submit = false,
+  page = "configuration",
 }: {
   session: RelaySession;
-  submit?: boolean;
+  page?: ReviewPage;
   readPull?: ReadPull;
+  onNavigate?: ((page: ReviewPage) => Promise<void>) | undefined;
   onOpenThread?: ((channel: string, id: string) => Promise<void>) | undefined;
 }) {
   const list = useChannelList(session.channels);
@@ -135,6 +161,18 @@ export function ReviewConfigurationCommunity({
     }
   });
   const [editing, setEditing] = useState(false);
+  const [navigationError, setNavigationError] = useState("");
+  async function navigate(destination: ReviewPage) {
+    try {
+      await onNavigate?.(destination);
+    } catch (reason) {
+      setNavigationError(
+        reason instanceof Error
+          ? reason.message
+          : "Could not open review page.",
+      );
+    }
+  }
   const channels = list.channels.filter(
     (item) =>
       !item.metadataPending &&
@@ -166,8 +204,36 @@ export function ReviewConfigurationCommunity({
     !selected.readOnly &&
     !!session.configArtifactWriter;
   return (
-    <Frame submit={submit}>
-      {submit && channels.length === 1 ? (
+    <Frame page={page}>
+      <div className="review-config-actions">
+        {page !== "configuration" && (
+          <Button
+            disabled={editing || !onNavigate}
+            onClick={() => void navigate("configuration")}
+          >
+            <ArrowLeftIcon /> Back to Review Configuration
+          </Button>
+        )}
+        {page !== "submit" && (
+          <Button
+            variant="prominent"
+            disabled={editing || !onNavigate}
+            onClick={() => void navigate("submit")}
+          >
+            Submit PR
+          </Button>
+        )}
+        {page !== "all" && (
+          <Button
+            disabled={editing || !onNavigate}
+            onClick={() => void navigate("all")}
+          >
+            All PRs
+          </Button>
+        )}
+      </div>
+      {navigationError && <p role="alert">{navigationError}</p>}
+      {page !== "configuration" && channels.length === 1 ? (
         <p className="text-caption text-subtle">
           Review channel: {selected?.name}
         </p>
@@ -202,9 +268,10 @@ export function ReviewConfigurationCommunity({
         </p>
       )}
       {channel &&
-        (submit ? (
+        (page !== "configuration" ? (
           <ReviewSubmissions
-            key={channel}
+            key={`${channel}:${page}`}
+            mode={page}
             session={session}
             channel={channel}
             writable={writable}
diff --git a/src/bundled/review-configuration/ReviewSubmissions.test.tsx b/src/bundled/review-configuration/ReviewSubmissions.test.tsx
index 0361a8dc09..d1ef1fd0d0 100644
--- a/src/bundled/review-configuration/ReviewSubmissions.test.tsx
+++ b/src/bundled/review-configuration/ReviewSubmissions.test.tsx
@@ -14,6 +14,7 @@ import { ReviewSubmissions } from "./ReviewSubmissions";
 import { loadConfigurations, type SavedReviewConfig } from "./configuration";
 import {
   loadSubmissions,
+  deleteSubmission,
   submitReview,
   type SavedSubmission,
 } from "./submissions";
@@ -25,6 +26,7 @@ vi.mock("./configuration", async (original) => ({
 vi.mock("./submissions", async (original) => ({
   ...(await original<typeof import("./submissions")>()),
   loadSubmissions: vi.fn(),
+  deleteSubmission: vi.fn(),
   submitReview: vi.fn(),
 }));
 afterEach(cleanup);
@@ -75,7 +77,10 @@ beforeEach(() => {
     },
   );
 });
-function fixture() {
+function fixture(
+  mode: "submit" | "all" = "submit",
+  viewer = record.value.submitter,
+) {
   const agents = [{ pubkey: "a".repeat(64), name: "UI Reviewer" }];
   const choices = {
     identities: agents,
@@ -84,6 +89,7 @@ function fixture() {
     archives: { status: "ready" },
   };
   const session = {
+    viewer,
     agentChoices: {
       subscribe: () => () => {},
       snapshot: () => choices,
@@ -106,6 +112,7 @@ function fixture() {
   const view = render(
     <ReviewSubmissions
       session={session}
+      mode={mode}
       channel="channel"
       writable
       onEditingChange={editing}
@@ -251,17 +258,109 @@ it("guards repeated clicks and aborts pending work when its page unmounts", asyn
   await act(async () => finish());
 });
 
-it("focuses the URL after selecting a previous PR without dispatching", async () => {
+it("shows all PRs in a table without submission controls, and deletion requires confirmation", async () => {
   vi.mocked(loadSubmissions).mockResolvedValue({ rows: [record], warning: "" });
-  const test = fixture();
+  const test = fixture("all");
+  const table = await screen.findByRole("table");
+  expect(
+    within(table).getByRole("columnheader", { name: "Reviewers & threads" }),
+  ).toBeTruthy();
+  expect(screen.queryByRole("textbox")).toBeNull();
   await test.user.click(
-    await screen.findByRole("button", { name: /example-org\/project#42/ }),
+    screen.getByRole("button", { name: "Delete example-org/project#42" }),
   );
-  await test.user.click(screen.getByRole("button", { name: "Use this PR" }));
-  const input = screen.getByRole("textbox", { name: "GitHub PR URL" });
-  expect(document.activeElement).toBe(input);
-  expect((input as HTMLInputElement).value).toBe(
-    "https://github.com/example-org/project/pull/42",
+  expect(deleteSubmission).not.toHaveBeenCalled();
+  await test.user.click(screen.getByRole("button", { name: "Cancel" }));
+  expect(screen.queryByRole("alertdialog")).toBeNull();
+  expect(screen.getByRole("table")).toBeTruthy();
+  await test.user.click(
+    screen.getByRole("button", { name: "Delete example-org/project#42" }),
+  );
+  await test.user.click(
+    screen.getByRole("button", { name: "Delete submission" }),
+  );
+  await waitFor(() => expect(screen.queryByRole("table")).toBeNull());
+  expect(deleteSubmission).toHaveBeenCalledWith(
+    test.session,
+    "channel",
+    record,
+    expect.any(AbortSignal),
   );
   expect(submitReview).not.toHaveBeenCalled();
 });
+
+it("keeps a row and explains recovery after an uncertain delete", async () => {
+  vi.mocked(loadSubmissions).mockResolvedValue({ rows: [record], warning: "" });
+  vi.mocked(deleteSubmission).mockRejectedValueOnce(
+    new Error("Write timed out"),
+  );
+  const test = fixture("all");
+  await test.user.click(
+    await screen.findByRole("button", {
+      name: "Delete example-org/project#42",
+    }),
+  );
+  await test.user.click(
+    screen.getByRole("button", { name: "Delete submission" }),
+  );
+  expect((await screen.findByRole("alert")).textContent).toContain("reload");
+  expect(screen.getByRole("table", { hidden: true })).toBeTruthy();
+  expect(screen.getByRole("alertdialog")).toBeTruthy();
+});
+
+it("does not allow deleting someone else's submission", async () => {
+  vi.mocked(loadSubmissions).mockResolvedValue({ rows: [record], warning: "" });
+  fixture("all", "other");
+  expect(
+    (
+      (await screen.findByRole("button", {
+        name: "Delete example-org/project#42",
+      })) as HTMLButtonElement
+    ).disabled,
+  ).toBe(true);
+});
+
+it("reload replaces the list so a submission deleted elsewhere disappears", async () => {
+  vi.mocked(loadSubmissions)
+    .mockResolvedValueOnce({ rows: [record], warning: "" })
+    .mockResolvedValue({ rows: [], warning: "" });
+  const test = fixture("all");
+  await screen.findByRole("table");
+  await test.user.click(screen.getByRole("button", { name: "Reload" }));
+  await waitFor(() => expect(screen.queryByRole("table")).toBeNull());
+});
+
+it("guards duplicate deletion and aborts it when leaving the page", async () => {
+  vi.mocked(loadSubmissions).mockResolvedValue({ rows: [record], warning: "" });
+  let finish = () => {};
+  let pending: AbortSignal | undefined;
+  vi.mocked(deleteSubmission).mockImplementationOnce(
+    async (_s, _c, _row, signal) => {
+      pending = signal;
+      await new Promise<void>((resolve) => {
+        finish = resolve;
+      });
+    },
+  );
+  const test = fixture("all");
+  await test.user.click(
+    await screen.findByRole("button", {
+      name: "Delete example-org/project#42",
+    }),
+  );
+  await test.user.click(
+    screen.getByRole("button", { name: "Delete submission" }),
+  );
+  await waitFor(() => expect(deleteSubmission).toHaveBeenCalledTimes(1));
+  await test.user.click(
+    screen.getByRole("button", { name: "Delete submission" }),
+  );
+  expect(deleteSubmission).toHaveBeenCalledTimes(1);
+  expect(
+    (screen.getByRole("button", { name: "Cancel" }) as HTMLButtonElement)
+      .disabled,
+  ).toBe(true);
+  test.unmount();
+  expect(pending?.aborted).toBe(true);
+  await act(async () => finish());
+});
diff --git a/src/bundled/review-configuration/ReviewSubmissions.tsx b/src/bundled/review-configuration/ReviewSubmissions.tsx
index 06a1362910..0d0aed0e16 100644
--- a/src/bundled/review-configuration/ReviewSubmissions.tsx
+++ b/src/bundled/review-configuration/ReviewSubmissions.tsx
@@ -1,7 +1,7 @@
 import { useEffect, useRef, useState } from "react";
 import { useAgentChoices } from "../../features/agents/use-choices";
 import type { RelaySession } from "../../features/relay/session";
-import { Accordion } from "../../shared/design-system/ui/Accordion";
+import { AlertDialog } from "../../shared/design-system/ui/AlertDialog";
 import { Button } from "../../shared/design-system/ui/Button";
 import { Field } from "../../shared/design-system/ui/Field";
 import { InlineHeader } from "../../shared/design-system/ui/Header";
@@ -12,6 +12,7 @@ import { loadConfigurations } from "./configuration";
 import { createPullReader, type ReadPull } from "./pull-facts";
 import {
   loadSubmissions,
+  deleteSubmission,
   prUrl,
   pullRepository,
   pullRequest,
@@ -24,6 +25,7 @@ const publicPullReader = createPullReader();
 
 export function ReviewSubmissions({
   session,
+  mode = "submit",
   channel,
   writable,
   onEditingChange,
@@ -31,6 +33,7 @@ export function ReviewSubmissions({
   readPull = publicPullReader,
 }: {
   session: RelaySession;
+  mode?: "submit" | "all";
   channel: string;
   writable: boolean;
   onEditingChange: (editing: boolean) => void;
@@ -45,6 +48,10 @@ export function ReviewSubmissions({
   const [result, setResult] = useState<SavedSubmission>();
   const [rows, setRows] = useState<SavedSubmission[]>([]);
   const input = useRef<HTMLInputElement>(null);
+  const listHeading = useRef<HTMLDivElement>(null);
+  const deleteTrigger = useRef<HTMLButtonElement | null>(null);
+  const [removing, setRemoving] = useState<SavedSubmission>();
+  const [deleteError, setDeleteError] = useState("");
   const [listLoading, setListLoading] = useState(true);
   const [listError, setListError] = useState("");
   const [warning, setWarning] = useState("");
@@ -52,11 +59,12 @@ export function ReviewSubmissions({
   const operation = useRef<AbortController | undefined>(undefined);
   useEffect(() => () => operation.current?.abort(), []);
   useEffect(() => {
-    onEditingChange(busy || !!pr.trim());
+    onEditingChange(busy || !!removing || (!result && !!pr.trim()));
     return () => onEditingChange(false);
-  }, [busy, pr, onEditingChange]);
+  }, [busy, pr, result, removing, onEditingChange]);
   // biome-ignore lint/correctness/useExhaustiveDependencies: Reload is an explicit fresh read.
   useEffect(() => {
+    if (mode !== "all") return;
     const controller = new AbortController();
     setListError("");
     setListLoading(true);
@@ -67,14 +75,7 @@ export function ReviewSubmissions({
     )
       .then((next) => {
         if (controller.signal.aborted) return;
-        // A list read can finish after Submit; keep the action's newer result.
-        setRows((current) => [
-          ...current,
-          ...next.rows.filter(
-            (row) =>
-              !current.some((item) => item.artifactId === row.artifactId),
-          ),
-        ]);
+        setRows(next.rows);
         setWarning(next.warning);
       })
       .catch((reason: unknown) => {
@@ -89,7 +90,7 @@ export function ReviewSubmissions({
         if (!controller.signal.aborted) setListLoading(false);
       });
     return () => controller.abort();
-  }, [session, channel, reload]);
+  }, [session, channel, reload, mode]);
 
   async function submit() {
     if (operation.current || !writable) return;
@@ -135,10 +136,6 @@ export function ReviewSubmissions({
             (thread) => thread.delivered,
           );
           setResult(next);
-          setRows((current) => [
-            next,
-            ...current.filter((row) => row.artifactId !== next.artifactId),
-          ]);
         },
         true,
         () => readPull(repository, pullRequest(pr, repository), signal),
@@ -166,103 +163,211 @@ export function ReviewSubmissions({
     }
   }
 
+  async function remove() {
+    if (!removing || operation.current || !writable) return;
+    const controller = new AbortController();
+    operation.current = controller;
+    setBusy(true);
+    setDeleteError("");
+    try {
+      await deleteSubmission(
+        session,
+        channel,
+        removing,
+        AbortSignal.any([controller.signal, AbortSignal.timeout(20_000)]),
+      );
+      if (controller.signal.aborted) return;
+      setRows((current) =>
+        current.filter((row) => row.artifactId !== removing.artifactId),
+      );
+      setRemoving(undefined);
+      setStatus(
+        "Submission deleted from the list. Existing conversations are kept.",
+      );
+    } catch (reason) {
+      if (!controller.signal.aborted)
+        setDeleteError(
+          `${reason instanceof Error ? reason.message : "Could not delete submission."} Close this confirmation and reload to check the saved state before retrying.`,
+        );
+    } finally {
+      operation.current = undefined;
+      if (!controller.signal.aborted) setBusy(false);
+    }
+  }
+
   function threads(row: SavedSubmission) {
     return (
-      <section
-        className="review-config-form"
-        aria-label={`${row.value.config.repository}#${row.value.pr} reviewers`}
-      >
+      <div className="review-config-reviewers">
         {row.value.threads.map((thread, index) => {
           const lane = submissionLane(row.value, index);
           return (
             <div
               key={lane?.id ?? "overview"}
-              className="review-config-actions review-config-result-row"
+              className="review-config-thread-cell"
             >
               <span className="text-caption text-subtle">
-                {lane?.name ?? "Overview (earlier submission)"}
+                {lane?.name ?? "Overview"}
               </span>
-              {lane?.reviewers.map((pubkey) => (
-                <ReviewerIdentity
-                  key={pubkey}
-                  pubkey={pubkey}
-                  choices={choices}
-                />
-              ))}
-              <div className="review-config-actions">
-                {thread.id ? (
-                  <Button
-                    disabled={busy || !onOpenThread}
-                    onClick={async () => {
-                      try {
-                        if (thread.id) await onOpenThread?.(channel, thread.id);
-                      } catch (reason) {
-                        setError(
-                          reason instanceof Error
-                            ? reason.message
-                            : "Could not open thread.",
-                        );
-                      }
-                    }}
-                  >
-                    Open {lane?.name ?? "overview"} thread
-                  </Button>
-                ) : (
-                  <span>Thread delivery pending</span>
-                )}
-                {!thread.delivered && thread.id && (
-                  <span>Delivery unconfirmed</span>
-                )}
+              <div>
+                {lane?.reviewers.map((pubkey) => (
+                  <ReviewerIdentity
+                    key={pubkey}
+                    pubkey={pubkey}
+                    choices={choices}
+                  />
+                ))}
               </div>
+              {thread.id ? (
+                <Button
+                  size="sm"
+                  disabled={busy || !onOpenThread}
+                  onClick={async () => {
+                    try {
+                      if (thread.id) await onOpenThread?.(channel, thread.id);
+                    } catch (reason) {
+                      setError(
+                        reason instanceof Error
+                          ? reason.message
+                          : "Could not open thread.",
+                      );
+                    }
+                  }}
+                >
+                  Open {lane?.name ?? "overview"} thread
+                </Button>
+              ) : (
+                <span>Thread delivery pending</span>
+              )}
             </div>
           );
         })}
+      </div>
+    );
+  }
+
+  function table(records: SavedSubmission[], deletable: boolean) {
+    return (
+      <section
+        className="review-config-table-scroll"
+        aria-label="Submitted PRs table"
+        // biome-ignore lint/a11y/noNoninteractiveTabindex: The table scrollport must support keyboard horizontal scrolling.
+        tabIndex={0}
+      >
+        <table className="review-config-table text-body-sm">
+          <thead>
+            <tr>
+              <th scope="col">Pull request</th>
+              <th scope="col">Delivery</th>
+              <th scope="col">Reviewers &amp; threads</th>
+              {deletable && <th scope="col">Actions</th>}
+            </tr>
+          </thead>
+          <tbody>
+            {records.map((row) => (
+              <tr key={row.artifactId}>
+                <th scope="row">
+                  <a href={prUrl(row.value)} target="_blank" rel="noreferrer">
+                    {row.value.config.repository}#{row.value.pr}
+                  </a>
+                </th>
+                <td>
+                  {row.value.threads.every((thread) => thread.delivered)
+                    ? "Requests delivered"
+                    : "Delivery incomplete"}
+                </td>
+                <td>{threads(row)}</td>
+                {deletable && (
+                  <td>
+                    <Button
+                      size="sm"
+                      disabled={
+                        busy ||
+                        listLoading ||
+                        !writable ||
+                        row.value.submitter !== session.viewer
+                      }
+                      onClick={(event) => {
+                        deleteTrigger.current = event.currentTarget;
+                        setDeleteError("");
+                        setRemoving(row);
+                      }}
+                      aria-label={`Delete ${row.value.config.repository}#${row.value.pr}`}
+                    >
+                      Delete
+                    </Button>
+                    {row.value.submitter !== session.viewer && (
+                      <p className="text-caption text-subtle">
+                        Only the submitter can delete.
+                      </p>
+                    )}
+                  </td>
+                )}
+              </tr>
+            ))}
+          </tbody>
+        </table>
       </section>
     );
   }
 
   return (
     <section className="review-config-form" aria-label="PR submissions">
-      <form
-        className="review-config-form"
-        onSubmit={(event) => {
-          event.preventDefault();
-          void submit();
-        }}
-      >
-        <Field
-          label="GitHub PR URL"
-          description="We’ll assign a reviewer to each matching lane. Submitting an existing PR notifies its reviewers again."
+      {mode === "submit" && (
+        <form
+          className="review-config-form"
+          onSubmit={(event) => {
+            event.preventDefault();
+            void submit();
+          }}
         >
-          <Input
-            ref={input}
-            required
-            maxLength={300}
-            value={pr}
-            disabled={busy}
-            placeholder="https://github.com/example-org/project/pull/123"
-            autoCapitalize="none"
-            autoCorrect="off"
-            spellCheck={false}
-            onValueChange={(value) => {
-              setPr(value);
-              setError("");
-              setStatus("");
-              setResult(undefined);
-            }}
-          />
-        </Field>
-        <div>
-          <Button
-            type="submit"
-            variant="prominent"
-            loading={busy}
-            disabled={!writable || !pr.trim()}
+          <Field
+            label="GitHub PR URL"
+            description="We’ll assign a reviewer to each matching lane. Submitting an existing PR notifies its reviewers again."
           >
-            Submit PR
-          </Button>
-        </div>
-      </form>
+            <Input
+              ref={input}
+              required
+              maxLength={300}
+              value={pr}
+              disabled={busy}
+              placeholder="https://github.com/example-org/project/pull/123"
+              autoCapitalize="none"
+              autoCorrect="off"
+              spellCheck={false}
+              onValueChange={(value) => {
+                setPr(value);
+                setError("");
+                setStatus("");
+                setResult(undefined);
+              }}
+            />
+          </Field>
+          <div>
+            <Button
+              type="submit"
+              variant="prominent"
+              loading={busy}
+              disabled={!writable || !pr.trim()}
+            >
+              Submit PR
+            </Button>
+          </div>
+          {pr && (
+            <Button
+              disabled={busy}
+              onClick={() => {
+                setPr("");
+                setResult(undefined);
+                setError("");
+                setStatus("");
+                input.current?.focus();
+              }}
+            >
+              Clear
+            </Button>
+          )}
+        </form>
+      )}
       {error && <p role="alert">{error}</p>}
       {status && <p role="status">{status}</p>}
       {result && (
@@ -270,76 +375,77 @@ export function ReviewSubmissions({
           <InlineHeader
             title={`${result.value.config.repository}#${result.value.pr}`}
           />
-          {threads(result)}
+          {table([result], false)}
         </section>
       )}
-      <section className="review-config-form" aria-label="Existing PRs">
-        <InlineHeader title="Existing PRs" />
-        <LoadingRegion
-          pending={listLoading}
-          label="Loading submissions…"
-          statusVisibility="screen-reader"
-        >
-          {!listLoading && !listError && !rows.length && (
-            <p>No PRs submitted in this channel yet.</p>
+      {mode === "all" && (
+        <section className="review-config-form" aria-label="All PRs">
+          <div ref={listHeading} tabIndex={-1}>
+            <InlineHeader
+              title="Submitted pull requests"
+              actions={
+                <Button
+                  disabled={busy || listLoading || !!removing}
+                  onClick={() => {
+                    setStatus("");
+                    setReload((value) => value + 1);
+                  }}
+                >
+                  Reload
+                </Button>
+              }
+            />
+          </div>
+          <LoadingRegion
+            pending={listLoading}
+            label="Loading submissions…"
+            statusVisibility="screen-reader"
+          >
+            {!listLoading && !listError && !rows.length && (
+              <p>
+                {warning
+                  ? "No readable submissions in this result."
+                  : "No submissions in the list. Use Submit PR to start a review."}
+              </p>
+            )}
+            {rows.length > 0 && table(rows, true)}
+          </LoadingRegion>
+          {listError && (
+            <p role="alert">{listError} Use Reload to try again.</p>
           )}
-        </LoadingRegion>
-        {listError && (
-          <>
-            <p role="alert">{listError}</p>
-            <div>
+          {warning && <p role="alert">{warning}</p>}
+        </section>
+      )}
+      {removing && (
+        <AlertDialog
+          title={`Delete ${removing.value.config.repository}#${removing.value.pr}?`}
+          description="Remove this submission from the shared list. The GitHub PR and existing conversations stay available. This does not stop an active review. Submitting the same URL again restores its saved reviewers and threads."
+          pending={busy}
+          finalFocus={() =>
+            deleteTrigger.current?.isConnected
+              ? deleteTrigger.current
+              : listHeading.current
+          }
+          onClose={() => setRemoving(undefined)}
+          actions={
+            <>
+              <Button disabled={busy} onClick={() => setRemoving(undefined)}>
+                Cancel
+              </Button>
               <Button
-                disabled={busy}
-                onClick={() => setReload((value) => value + 1)}
+                variant="prominent"
+                disabled={!writable}
+                loading={busy}
+                onClick={() => void remove()}
               >
-                Reload submissions
+                Delete submission
               </Button>
-            </div>
-          </>
-        )}
-        {warning && <p role="alert">{warning}</p>}
-        <Accordion
-          variant="form"
-          items={rows
-            .filter((row) => row.artifactId !== result?.artifactId)
-            .map((row) => ({
-              value: row.artifactId,
-              title: (
-                <span className="review-config-pr-summary">
-                  <span>
-                    {row.value.config.repository}#{row.value.pr}
-                  </span>
-                  <span className="text-caption text-subtle">
-                    {row.value.threads.every((thread) => thread.delivered)
-                      ? "Requests delivered"
-                      : "Delivery incomplete"}
-                  </span>
-                </span>
-              ),
-              content: (
-                <div className="review-config-form">
-                  {threads(row)}
-                  <div>
-                    <Button
-                      disabled={busy}
-                      onClick={() => {
-                        setPr(prUrl(row.value));
-                        input.current?.focus();
-                        setResult(row);
-                        setError("");
-                        setStatus(
-                          "Submit again to notify reviewers or resume incomplete delivery.",
-                        );
-                      }}
-                    >
-                      Use this PR
-                    </Button>
-                  </div>
-                </div>
-              ),
-            }))}
-        />
-      </section>
+            </>
+          }
+        >
+          {deleteError && <p role="alert">{deleteError}</p>}
+        </AlertDialog>
+      )}
     </section>
   );
 }
diff --git a/src/bundled/review-configuration/index.tsx b/src/bundled/review-configuration/index.tsx
index a76efb3979..82113be88b 100644
--- a/src/bundled/review-configuration/index.tsx
+++ b/src/bundled/review-configuration/index.tsx
@@ -1,22 +1,26 @@
 import { gitHubCli } from "../github/gh";
 import { createPullReader } from "./pull-facts";
 import type { PluginModule } from "../../plugins/api";
-import { ReviewConfigurationPage } from "./ReviewConfigurationPage";
+import {
+  ReviewConfigurationPage,
+  reviewPageTitle,
+  type ReviewPage,
+} from "./ReviewConfigurationPage";
 
 export const inject = ["pages", "relay", "navigation", "host"];
 export const apply: PluginModule["apply"] = (ctx) => {
   const { relay, navigation: navigator } = ctx;
   const readPull = createPullReader(gitHubCli(ctx.host));
-  for (const submit of [false, true])
+  for (const page of ["configuration", "submit", "all"] satisfies ReviewPage[])
     ctx.pages.register({
-      id: submit ? "submit" : "configuration",
-      title: submit ? "Submit PR" : "Review Configuration",
+      id: page,
+      title: reviewPageTitle(page),
       layout: "workspace",
-      primary: true,
+      primary: page === "configuration",
       placement: "sidebar",
       component: () => (
         <ReviewConfigurationPage
-          submit={submit}
+          page={page}
           relay={relay}
           navigator={navigator}
           readPull={readPull}
diff --git a/src/bundled/review-configuration/review-configuration.css b/src/bundled/review-configuration/review-configuration.css
index bb90f119f5..bb0a1fca89 100644
--- a/src/bundled/review-configuration/review-configuration.css
+++ b/src/bundled/review-configuration/review-configuration.css
@@ -106,3 +106,43 @@
 .review-config-result-row {
   align-items: center;
 }
+
+.review-config-table-scroll {
+  max-width: 100%;
+  overflow-x: auto;
+  border: 1px solid var(--border-standard);
+  border-radius: var(--radius-container);
+}
+.review-config-table {
+  width: 100%;
+  min-width: 44rem;
+  border-collapse: collapse;
+  background: var(--surface-panel);
+}
+.review-config-table th,
+.review-config-table td {
+  text-align: left;
+  vertical-align: top;
+  padding: var(--space-3);
+  overflow-wrap: anywhere;
+}
+.review-config-table thead {
+  background: var(--surface-inset);
+}
+.review-config-table tbody tr {
+  border-top: 1px solid var(--border-standard);
+}
+.review-config-thread-cell {
+  display: grid;
+  grid-template-columns: minmax(3rem, auto) minmax(7rem, 1fr) auto;
+  align-items: center;
+  gap: var(--space-2);
+}
+.review-config-thread-cell + .review-config-thread-cell {
+  border-top: 1px solid var(--border-standard);
+  padding-top: var(--space-3);
+}
+
+.review-config-content[data-review-page="all"] {
+  max-width: 72rem;
+}
diff --git a/src/bundled/review-configuration/submissions.test.ts b/src/bundled/review-configuration/submissions.test.ts
index a931830b6c..55f9f28d65 100644
--- a/src/bundled/review-configuration/submissions.test.ts
+++ b/src/bundled/review-configuration/submissions.test.ts
@@ -7,6 +7,7 @@ import type { RelaySession } from "../../features/relay/session";
 import { keypair, signed } from "../../features/relay/testing";
 import {
   loadSubmissions,
+  deleteSubmission,
   pullRequest,
   pullRepository,
   submitReview,
@@ -644,3 +645,52 @@ it("retries a partially delivered notification batch with the same message ident
   ).toHaveLength(2);
   expect((await test.run()).value.threads).toEqual(first.value.threads);
 });
+
+it("deletes from the shared list and restores the same threads on resubmission after reload", async () => {
+  const f = await fixture();
+  const record = await f.run();
+  await deleteSubmission(
+    f.session,
+    channel,
+    record,
+    new AbortController().signal,
+  );
+  expect(
+    (await loadSubmissions(f.session, channel, new AbortController().signal))
+      .rows,
+  ).toEqual([]);
+  expect(f.messages.size).toBe(2);
+  const restored = await f.run("123", new AbortController().signal, true);
+  expect(restored.value.deleted).toBeUndefined();
+  expect(restored.value.threads).toEqual(record.value.threads);
+  expect(f.messages.size).toBe(2);
+  expect(
+    (await loadSubmissions(f.session, channel, new AbortController().signal))
+      .rows,
+  ).toHaveLength(1);
+});
+
+it("rejects foreign submitters and stale deletion without changing the saved list", async () => {
+  const f = await fixture();
+  const record = await f.run();
+  await expect(
+    deleteSubmission(
+      { ...f.session, viewer: keypair().pubkey },
+      channel,
+      record,
+      new AbortController().signal,
+    ),
+  ).rejects.toThrow("Only the original submitter");
+  await expect(
+    deleteSubmission(
+      f.session,
+      channel,
+      { ...record, revision: "0".repeat(64) },
+      new AbortController().signal,
+    ),
+  ).rejects.toThrow("changed");
+  expect(
+    (await loadSubmissions(f.session, channel, new AbortController().signal))
+      .rows,
+  ).toHaveLength(1);
+});
diff --git a/src/bundled/review-configuration/submissions.ts b/src/bundled/review-configuration/submissions.ts
index d6306f1583..98a0750bb9 100644
--- a/src/bundled/review-configuration/submissions.ts
+++ b/src/bundled/review-configuration/submissions.ts
@@ -28,6 +28,7 @@ export type Submission = {
   submitter: string;
   device: string;
   threads: Thread[];
+  deleted?: true;
 };
 export type SavedSubmission = {
   value: Submission;
@@ -93,6 +94,7 @@ async function decode(
     value.submitter !== event.pubkey ||
     !HEX.test(value.configRevision) ||
     !UUID.test(value.device) ||
+    (value.deleted !== undefined && value.deleted !== true) ||
     config.lanes.some((lane) => lane.reviewers.length !== 1) ||
     !Array.isArray(value.threads) ||
     value.threads.length !==
@@ -137,10 +139,14 @@ export async function loadSubmissions(
   );
   return {
     rows: results.flatMap((result) =>
-      result.status === "fulfilled" ? [result.value] : [],
+      result.status === "fulfilled" && !result.value.value.deleted
+        ? [result.value]
+        : [],
     ),
     warning: [
-      events.length > 100 ? "Showing the latest 100 submissions." : "",
+      events.length > 100
+        ? "Showing results from the latest 100 saved records, including deleted entries."
+        : "",
       results.some((result) => result.status === "rejected")
         ? "Some saved submissions could not be read."
         : "",
@@ -182,6 +188,54 @@ async function write(
   return { value, artifactId, revision: event.id };
 }
 
+/** Remove from the shared list, retaining recovery and thread identity for resubmission. */
+export async function deleteSubmission(
+  session: RelaySession,
+  channel: string,
+  previous: SavedSubmission,
+  signal: AbortSignal,
+) {
+  if (!session.viewer || previous.value.submitter !== session.viewer)
+    throw new Error("Only the original submitter can delete this submission.");
+  const read = session.snapshotRead;
+  if (!read || !navigator.locks)
+    throw new Error("Submission deletion is unavailable.");
+  return navigator.locks.request(
+    `buzz.review.submit:${session.scope}`,
+    { signal },
+    async () => {
+      const events = await read(
+        [
+          {
+            kinds: [ARTIFACT_KIND],
+            "#h": [channel],
+            "#d": [previous.artifactId],
+            artifact: "current",
+            limit: 1,
+          },
+        ],
+        { signal },
+      );
+      const head = events[0];
+      if (!head) throw new Error("Submission is unavailable. Reload the list.");
+      const current = await decode(head, channel);
+      if (current.value.submitter !== session.viewer)
+        throw new Error(
+          "Only the original submitter can delete this submission.",
+        );
+      if (current.revision !== previous.revision)
+        throw new Error("Submission changed. Reload the list before deleting.");
+      await write(
+        session,
+        channel,
+        { ...current.value, deleted: true },
+        current,
+        signal,
+      );
+    },
+  );
+}
+
 /** Device ownership is recovery coordination, never permission. The relay still
  * authorizes every write. Shared Web Locks serialize tabs; artifact create/CAS
  * serializes devices. Losing this profile cannot authorize replacement sends. */
@@ -453,6 +507,14 @@ export async function submitReview(
         await eligible(session, value, signal);
         record = await write(session, channel, value, undefined, signal);
       }
+      if (record.value.deleted && (resume || notifyExisting)) {
+        if (record.value.submitter !== session.viewer)
+          throw new Error(
+            "Only the original submitter can restore this deleted submission.",
+          );
+        const { deleted: _deleted, ...value } = record.value;
+        record = await write(session, channel, value, record, signal);
+      }
       onProgress(record);
       // The dedicated Submit action may notify; passive readers never dispatch.
       if (head && !resume && !notifyExisting) return record;

From 4be5f1fb8795f40125db68da74ea6a09e7a8ac07 Mon Sep 17 00:00:00 2001
From: Ravneet Arora <rarora@squareup.com>
Date: Thu, 12 Nov 2026 15:19:32 -0500
Subject: [PATCH 10/17] fix(review): group page navigation in a menu

Co-authored-by: maincourse <37ce551b493d4a998caf030929c47bce0b6a0e43f1178b3a63c4151d7c16b76e@buzz.block.builderlab.xyz>
Signed-off-by: Ravneet Arora <rarora@squareup.com>
---
 docs/buzz-help.md                             |  4 +-
 src/bundled/review-configuration/README.md    |  4 +-
 .../ReviewConfigurationPage.test.tsx          | 18 ++---
 .../ReviewConfigurationPage.tsx               | 69 +++++++++++--------
 4 files changed, 54 insertions(+), 41 deletions(-)

diff --git a/docs/buzz-help.md b/docs/buzz-help.md
index 9e91cf1b75..04f60dd6e9 100644
--- a/docs/buzz-help.md
+++ b/docs/buzz-help.md
@@ -1161,7 +1161,7 @@ confirmation. **Delete team** asks first; it doesn't delete the team's agents.
   reads the latest saved versions. Settings live on the community relay and are
   visible to channel readers; members who can post can edit them. A conflicting
   edit preserves your draft: copy your changes before cancelling and reloading.
-  **Review Configuration** has repository and lane settings plus **Submit PR** and **All PRs** buttons that open separate pages. **Edit lane**
+  **Review Configuration** has repository and lane settings plus **Review menu** with **Review Configuration**, **Submit PR**, and **All PRs** that open separate pages. **Edit lane**
   opens one lane; **Save lane** persists it before **Add lane** starts another.
   **Back to lanes** cancels the editor; **Back to repositories** returns to the list.
   Every new or edited lane requires at least one all/any routing rule matching
@@ -1175,7 +1175,7 @@ confirmation. **Delete team** asks first; it doesn't delete the team's agents.
   Submitting an existing PR reuses its saved reviewers and threads and mentions
   them again in those threads. Incomplete initial delivery resumes from the original
   browser profile. An interrupted notification retries its saved messages.
-  No configuration controls appear on Submit PR or All PRs. Both have a Back button. All pages remember the selected
+  No configuration controls appear on Submit PR or All PRs. Use the header Review menu to return to configuration or switch pages. All pages remember the selected
   review channel. Reviewers must be owned by the signed-in identity and already
   belong to the channel. A connected agent runtime is needed for replies;
   delivery alone does not mean a review started. Desktop uses signed-in GitHub
diff --git a/src/bundled/review-configuration/README.md b/src/bundled/review-configuration/README.md
index f25fa450a5..74883ab08f 100644
--- a/src/bundled/review-configuration/README.md
+++ b/src/bundled/review-configuration/README.md
@@ -6,7 +6,7 @@ Choose a channel, register a GitHub repository, add named lanes, reviewer agents
 and save. Open a repository row to manage its lanes. Saved cards show agents,
 instructions, and routing rules. **Edit lane** opens one lane; **Save lane** persists
 it before another can be added. **Back to lanes** cancels edits; **Back to repositories**
-returns to the list. The main page has **Submit PR** and **All PRs** buttons that open separate pages.
+returns to the list. The header **Review menu** opens **Review Configuration**, **Submit PR**, and **All PRs** with consistent navigation on every page.
 
 The **Submit PR** page has a full GitHub PR URL field and one
 Submit button. It finds the saved repository in the selected channel, loads current
@@ -21,7 +21,7 @@ threads or review rounds. Incomplete original submissions resume delivery from
 the original browser profile instead. These actions run only on Submit; opening
 the page or a thread never dispatches messages.
 
-All three pages use the shell's page navigation. Only Review Configuration appears in the sidebar; Submit PR and All PRs have buttons back to it. Repository and lane editing
+All three pages use the shell's page navigation. Only Review Configuration appears in the sidebar; the Review menu returns to it from Submit PR and All PRs. Repository and lane editing
 remain local sections; reloading returns Configuration to its repository list.
 The channel selection is remembered per identity/community; one eligible channel
 is selected automatically. Submit results can be recovered from All PRs
diff --git a/src/bundled/review-configuration/ReviewConfigurationPage.test.tsx b/src/bundled/review-configuration/ReviewConfigurationPage.test.tsx
index 65473c3862..b71ff536ff 100644
--- a/src/bundled/review-configuration/ReviewConfigurationPage.test.tsx
+++ b/src/bundled/review-configuration/ReviewConfigurationPage.test.tsx
@@ -496,9 +496,11 @@ it("opens dedicated pages from configuration and blocks leaving lane drafts", as
   await user.click(screen.getByRole("button", { name: "Save lane" }));
   await screen.findByText("Saved example-org/project.");
   expect(screen.queryByRole("region", { name: "PR submissions" })).toBeNull();
-  await user.click(screen.getByRole("button", { name: "Submit PR" }));
+  await user.click(screen.getByRole("button", { name: "Review menu" }));
+  await user.click(await screen.findByRole("menuitem", { name: "Submit PR" }));
   expect(onNavigate).toHaveBeenCalledWith("submit");
-  await user.click(screen.getByRole("button", { name: "All PRs" }));
+  await user.click(screen.getByRole("button", { name: "Review menu" }));
+  await user.click(await screen.findByRole("menuitem", { name: "All PRs" }));
   expect(onNavigate).toHaveBeenCalledWith("all");
   await user.click(screen.getByRole("button", { name: "Edit General lane" }));
   expect(
@@ -508,11 +510,7 @@ it("opens dedicated pages from configuration and blocks leaving lane drafts", as
   await user.clear(field);
   await user.type(field, "Preserve draft");
   expect(
-    (screen.getByRole("button", { name: "Submit PR" }) as HTMLButtonElement)
-      .disabled,
-  ).toBe(true);
-  expect(
-    (screen.getByRole("button", { name: "All PRs" }) as HTMLButtonElement)
+    (screen.getByRole("button", { name: "Review menu" }) as HTMLButtonElement)
       .disabled,
   ).toBe(true);
   expect((field as HTMLTextAreaElement).value).toBe("Preserve draft");
@@ -520,9 +518,11 @@ it("opens dedicated pages from configuration and blocks leaving lane drafts", as
   await user.click(
     screen.getByRole("button", { name: "Back to repositories" }),
   );
-  await user.click(screen.getByRole("button", { name: "Submit PR" }));
+  await user.click(screen.getByRole("button", { name: "Review menu" }));
+  await user.click(await screen.findByRole("menuitem", { name: "Submit PR" }));
   expect(onNavigate).toHaveBeenCalledWith("submit");
-  await user.click(screen.getByRole("button", { name: "All PRs" }));
+  await user.click(screen.getByRole("button", { name: "Review menu" }));
+  await user.click(await screen.findByRole("menuitem", { name: "All PRs" }));
   expect(onNavigate).toHaveBeenCalledWith("all");
   await user.click(
     screen.getByRole("button", { name: "Open example-org/project" }),
diff --git a/src/bundled/review-configuration/ReviewConfigurationPage.tsx b/src/bundled/review-configuration/ReviewConfigurationPage.tsx
index 768cdf3781..2d48a52ba1 100644
--- a/src/bundled/review-configuration/ReviewConfigurationPage.tsx
+++ b/src/bundled/review-configuration/ReviewConfigurationPage.tsx
@@ -13,9 +13,17 @@ import type { RelaySession } from "../../features/relay/session";
 import {
   ArrowLeftIcon,
   ListChecksIcon,
+  MenuIcon,
 } from "../../shared/design-system/icons";
 import { NavigationItem } from "../../shared/design-system/ui/NavigationItem";
 import { Button } from "../../shared/design-system/ui/Button";
+import { IconButton } from "../../shared/design-system/ui/IconButton";
+import {
+  MenuRoot,
+  MenuTrigger,
+  MenuPopup,
+  MenuItem,
+} from "../../shared/design-system/ui/Menu";
 import { Field } from "../../shared/design-system/ui/Field";
 import { FullPageSurface } from "../../shared/design-system/ui/FullPageSurface";
 import { InlineHeader } from "../../shared/design-system/ui/Header";
@@ -48,7 +56,9 @@ export const reviewPageTitle = (page: ReviewPage) =>
 function Frame({
   children,
   page = "configuration",
+  actions,
 }: {
+  actions?: ReactNode;
   children: ReactNode;
   page?: ReviewPage;
 }) {
@@ -58,6 +68,7 @@ function Frame({
       <div className="review-config-page text-body">
         <PanelHeader
           title={<PanelHeaderLabel title={title} icon={<ListChecksIcon />} />}
+          actions={actions}
         />
         <div className="review-config-scroll">
           <div className="review-config-content" data-review-page={page}>
@@ -204,34 +215,37 @@ export function ReviewConfigurationCommunity({
     !selected.readOnly &&
     !!session.configArtifactWriter;
   return (
-    <Frame page={page}>
-      <div className="review-config-actions">
-        {page !== "configuration" && (
-          <Button
+    <Frame
+      page={page}
+      actions={
+        <MenuRoot>
+          <MenuTrigger
             disabled={editing || !onNavigate}
-            onClick={() => void navigate("configuration")}
-          >
-            <ArrowLeftIcon /> Back to Review Configuration
-          </Button>
-        )}
-        {page !== "submit" && (
-          <Button
-            variant="prominent"
-            disabled={editing || !onNavigate}
-            onClick={() => void navigate("submit")}
-          >
-            Submit PR
-          </Button>
-        )}
-        {page !== "all" && (
-          <Button
-            disabled={editing || !onNavigate}
-            onClick={() => void navigate("all")}
-          >
-            All PRs
-          </Button>
-        )}
-      </div>
+            render={
+              <IconButton
+                aria-label="Review menu"
+                title="Review menu"
+                icon={<MenuIcon />}
+              />
+            }
+          />
+          <MenuPopup size="compact" align="end">
+            {(["configuration", "submit", "all"] as const).map(
+              (destination) => (
+                <MenuItem
+                  key={destination}
+                  disabled={editing || !onNavigate || page === destination}
+                  aria-current={page === destination ? "page" : undefined}
+                  onClick={() => void navigate(destination)}
+                >
+                  {reviewPageTitle(destination)}
+                </MenuItem>
+              ),
+            )}
+          </MenuPopup>
+        </MenuRoot>
+      }
+    >
       {navigationError && <p role="alert">{navigationError}</p>}
       {page !== "configuration" && channels.length === 1 ? (
         <p className="text-caption text-subtle">
@@ -396,7 +410,6 @@ function ChannelConfiguration({
             </Button>
             <Button
               ref={editorTrigger}
-              variant="prominent"
               disabled={loading || !!error || !writable || remaining <= 0}
               onClick={(event) => {
                 editorTrigger.current = event.currentTarget;

From df1913cc0c3b2d69af26899b820692c295878eab Mon Sep 17 00:00:00 2001
From: Ravneet Arora <rarora@squareup.com>
Date: Thu, 12 Nov 2026 15:30:13 -0500
Subject: [PATCH 11/17] Put review actions and PR table on the main page

Co-authored-by: maincourse <37ce551b493d4a998caf030929c47bce0b6a0e43f1178b3a63c4151d7c16b76e@buzz.block.builderlab.xyz>
Signed-off-by: Ravneet Arora <rarora@squareup.com>
---
 docs/buzz-help.md                             |   6 +-
 src/bundled/review-configuration/README.md    |   8 +-
 .../ReviewConfigurationPage.test.tsx          |  43 ++++--
 .../ReviewConfigurationPage.tsx               | 133 ++++++++++--------
 .../review-configuration.css                  |   3 +-
 5 files changed, 115 insertions(+), 78 deletions(-)

diff --git a/docs/buzz-help.md b/docs/buzz-help.md
index 04f60dd6e9..7d3e3261c8 100644
--- a/docs/buzz-help.md
+++ b/docs/buzz-help.md
@@ -1161,7 +1161,7 @@ confirmation. **Delete team** asks first; it doesn't delete the team's agents.
   reads the latest saved versions. Settings live on the community relay and are
   visible to channel readers; members who can post can edit them. A conflicting
   edit preserves your draft: copy your changes before cancelling and reloading.
-  **Review Configuration** has repository and lane settings plus **Review menu** with **Review Configuration**, **Submit PR**, and **All PRs** that open separate pages. **Edit lane**
+  **Review Configuration** has matching **Register repository** and **Submit PR** actions at the top, a **Repositories** section, and an expandable **Pull requests** table. **Edit lane**
   opens one lane; **Save lane** persists it before **Add lane** starts another.
   **Back to lanes** cancels the editor; **Back to repositories** returns to the list.
   Every new or edited lane requires at least one all/any routing rule matching
@@ -1171,11 +1171,11 @@ confirmation. **Delete team** asks first; it doesn't delete the team's agents.
   Submit button. It finds the repository in the selected review channel, reads
   current PR details, and assigns the first configured reviewer in each matching
   lane. Missing configuration or zero matching lanes sends nothing. Results show
-  assigned agents and their thread buttons. **All PRs** shows previous submissions in a bordered table. The original submitter can confirm **Delete** to remove a submission from the shared list; its conversations and GitHub PR remain. Deleting does not stop active reviews. Resubmitting restores its saved reviewers and threads.
+  assigned agents and their thread buttons. Expand **Pull requests** on the main page to see previous submissions in a bordered table. The original submitter can confirm **Delete** to remove a submission from the shared list; its conversations and GitHub PR remain. Deleting does not stop active reviews. Resubmitting restores its saved reviewers and threads.
   Submitting an existing PR reuses its saved reviewers and threads and mentions
   them again in those threads. Incomplete initial delivery resumes from the original
   browser profile. An interrupted notification retries its saved messages.
-  No configuration controls appear on Submit PR or All PRs. Use the header Review menu to return to configuration or switch pages. All pages remember the selected
+  The separate Submit PR form has a **Back to Review Configuration** button. All pages remember the selected
   review channel. Reviewers must be owned by the signed-in identity and already
   belong to the channel. A connected agent runtime is needed for replies;
   delivery alone does not mean a review started. Desktop uses signed-in GitHub
diff --git a/src/bundled/review-configuration/README.md b/src/bundled/review-configuration/README.md
index 74883ab08f..0dd161ff06 100644
--- a/src/bundled/review-configuration/README.md
+++ b/src/bundled/review-configuration/README.md
@@ -6,14 +6,14 @@ Choose a channel, register a GitHub repository, add named lanes, reviewer agents
 and save. Open a repository row to manage its lanes. Saved cards show agents,
 instructions, and routing rules. **Edit lane** opens one lane; **Save lane** persists
 it before another can be added. **Back to lanes** cancels edits; **Back to repositories**
-returns to the list. The header **Review menu** opens **Review Configuration**, **Submit PR**, and **All PRs** with consistent navigation on every page.
+returns to the list. The main page has matching **Register repository** and **Submit PR** actions above the **Repositories** section and an expandable **Pull requests** table.
 
 The **Submit PR** page has a full GitHub PR URL field and one
 Submit button. It finds the saved repository in the selected channel, loads current
 PR metadata, and assigns the first configured reviewer per matching lane. Missing
 configuration, unavailable reviewers, and zero matching lanes produce an error
 without starting threads. Results show assigned reviewers and thread buttons.
-**All PRs** shows previous submissions in a bordered table with delivery status, reviewer identities, and thread links. The submitter can confirm **Delete** to remove a submission from the shared list. This preserves its thread mapping and does not stop active reviews, delete conversations, or close the GitHub PR. Submitting that URL again restores the saved assignment and threads.
+The **Pull requests** section shows previous submissions in a bordered table with delivery status, reviewer identities, and thread links. The submitter can confirm **Delete** to remove a submission from the shared list. This preserves its thread mapping and does not stop active reviews, delete conversations, or close the GitHub PR. Submitting that URL again restores the saved assignment and threads.
 
 Submitting an already-delivered PR sends a reviewer mention in each saved lane
 thread. It preserves the saved reviewers and instructions and creates no new
@@ -21,10 +21,10 @@ threads or review rounds. Incomplete original submissions resume delivery from
 the original browser profile instead. These actions run only on Submit; opening
 the page or a thread never dispatches messages.
 
-All three pages use the shell's page navigation. Only Review Configuration appears in the sidebar; the Review menu returns to it from Submit PR and All PRs. Repository and lane editing
+All three pages use the shell's page navigation. Only Review Configuration appears in the sidebar; Submit PR has a Back button returning to it. The existing All PRs route remains available for saved navigation. Repository and lane editing
 remain local sections; reloading returns Configuration to its repository list.
 The channel selection is remembered per identity/community; one eligible channel
-is selected automatically. Submit results can be recovered from All PRs
+is selected automatically. Submit results can be recovered from the Pull requests table
 following reload; navigation never replays Submit automatically.
 
 ## Getting started
diff --git a/src/bundled/review-configuration/ReviewConfigurationPage.test.tsx b/src/bundled/review-configuration/ReviewConfigurationPage.test.tsx
index b71ff536ff..01a61f0d8a 100644
--- a/src/bundled/review-configuration/ReviewConfigurationPage.test.tsx
+++ b/src/bundled/review-configuration/ReviewConfigurationPage.test.tsx
@@ -496,12 +496,6 @@ it("opens dedicated pages from configuration and blocks leaving lane drafts", as
   await user.click(screen.getByRole("button", { name: "Save lane" }));
   await screen.findByText("Saved example-org/project.");
   expect(screen.queryByRole("region", { name: "PR submissions" })).toBeNull();
-  await user.click(screen.getByRole("button", { name: "Review menu" }));
-  await user.click(await screen.findByRole("menuitem", { name: "Submit PR" }));
-  expect(onNavigate).toHaveBeenCalledWith("submit");
-  await user.click(screen.getByRole("button", { name: "Review menu" }));
-  await user.click(await screen.findByRole("menuitem", { name: "All PRs" }));
-  expect(onNavigate).toHaveBeenCalledWith("all");
   await user.click(screen.getByRole("button", { name: "Edit General lane" }));
   expect(
     screen.queryByRole("button", { name: "Back to repositories" }),
@@ -509,21 +503,14 @@ it("opens dedicated pages from configuration and blocks leaving lane drafts", as
   const field = screen.getByRole("textbox", { name: "Instructions" });
   await user.clear(field);
   await user.type(field, "Preserve draft");
-  expect(
-    (screen.getByRole("button", { name: "Review menu" }) as HTMLButtonElement)
-      .disabled,
-  ).toBe(true);
+  expect(screen.queryByRole("button", { name: "Submit PR" })).toBeNull();
   expect((field as HTMLTextAreaElement).value).toBe("Preserve draft");
   await user.click(screen.getByRole("button", { name: "Cancel" }));
   await user.click(
     screen.getByRole("button", { name: "Back to repositories" }),
   );
-  await user.click(screen.getByRole("button", { name: "Review menu" }));
-  await user.click(await screen.findByRole("menuitem", { name: "Submit PR" }));
+  await user.click(screen.getByRole("button", { name: "Submit PR" }));
   expect(onNavigate).toHaveBeenCalledWith("submit");
-  await user.click(screen.getByRole("button", { name: "Review menu" }));
-  await user.click(await screen.findByRole("menuitem", { name: "All PRs" }));
-  expect(onNavigate).toHaveBeenCalledWith("all");
   await user.click(
     screen.getByRole("button", { name: "Open example-org/project" }),
   );
@@ -670,3 +657,29 @@ it("returns focus to the lane region after removing the edited lane", async () =
     ),
   ).toEqual(["General"]);
 });
+
+it("expands the PR list on the home page without opening another page", async () => {
+  const test = fixture();
+  const onNavigate = vi.fn(async () => {});
+  render(
+    <ReviewConfigurationCommunity
+      session={test.session}
+      onNavigate={onNavigate}
+    />,
+  );
+  const user = userEvent.setup();
+  await screen.findByRole("button", { name: "Register repository" });
+  expect(screen.queryByRole("region", { name: "All PRs" })).toBeNull();
+  const disclosure = screen.getByRole("button", { name: "Pull requests" });
+  await user.click(disclosure);
+  await screen.findByText(
+    "No submissions in the list. Use Submit PR to start a review.",
+  );
+  expect(onNavigate).not.toHaveBeenCalled();
+  await user.click(disclosure);
+  await waitFor(() =>
+    expect(disclosure.getAttribute("aria-expanded")).toBe("false"),
+  );
+  await user.click(screen.getByRole("button", { name: "Submit PR" }));
+  expect(onNavigate).toHaveBeenCalledWith("submit");
+});
diff --git a/src/bundled/review-configuration/ReviewConfigurationPage.tsx b/src/bundled/review-configuration/ReviewConfigurationPage.tsx
index 2d48a52ba1..a848bb5cf7 100644
--- a/src/bundled/review-configuration/ReviewConfigurationPage.tsx
+++ b/src/bundled/review-configuration/ReviewConfigurationPage.tsx
@@ -13,17 +13,10 @@ import type { RelaySession } from "../../features/relay/session";
 import {
   ArrowLeftIcon,
   ListChecksIcon,
-  MenuIcon,
 } from "../../shared/design-system/icons";
 import { NavigationItem } from "../../shared/design-system/ui/NavigationItem";
 import { Button } from "../../shared/design-system/ui/Button";
-import { IconButton } from "../../shared/design-system/ui/IconButton";
-import {
-  MenuRoot,
-  MenuTrigger,
-  MenuPopup,
-  MenuItem,
-} from "../../shared/design-system/ui/Menu";
+import { Accordion } from "../../shared/design-system/ui/Accordion";
 import { Field } from "../../shared/design-system/ui/Field";
 import { FullPageSurface } from "../../shared/design-system/ui/FullPageSurface";
 import { InlineHeader } from "../../shared/design-system/ui/Header";
@@ -56,9 +49,7 @@ export const reviewPageTitle = (page: ReviewPage) =>
 function Frame({
   children,
   page = "configuration",
-  actions,
 }: {
-  actions?: ReactNode;
   children: ReactNode;
   page?: ReviewPage;
 }) {
@@ -68,7 +59,6 @@ function Frame({
       <div className="review-config-page text-body">
         <PanelHeader
           title={<PanelHeaderLabel title={title} icon={<ListChecksIcon />} />}
-          actions={actions}
         />
         <div className="review-config-scroll">
           <div className="review-config-content" data-review-page={page}>
@@ -214,39 +204,8 @@ export function ReviewConfigurationCommunity({
     !selected.cached &&
     !selected.readOnly &&
     !!session.configArtifactWriter;
-  return (
-    <Frame
-      page={page}
-      actions={
-        <MenuRoot>
-          <MenuTrigger
-            disabled={editing || !onNavigate}
-            render={
-              <IconButton
-                aria-label="Review menu"
-                title="Review menu"
-                icon={<MenuIcon />}
-              />
-            }
-          />
-          <MenuPopup size="compact" align="end">
-            {(["configuration", "submit", "all"] as const).map(
-              (destination) => (
-                <MenuItem
-                  key={destination}
-                  disabled={editing || !onNavigate || page === destination}
-                  aria-current={page === destination ? "page" : undefined}
-                  onClick={() => void navigate(destination)}
-                >
-                  {reviewPageTitle(destination)}
-                </MenuItem>
-              ),
-            )}
-          </MenuPopup>
-        </MenuRoot>
-      }
-    >
-      {navigationError && <p role="alert">{navigationError}</p>}
+  const channelSelector = (
+    <>
       {page !== "configuration" && channels.length === 1 ? (
         <p className="text-caption text-subtle">
           Review channel: {selected?.name}
@@ -281,6 +240,22 @@ export function ReviewConfigurationCommunity({
           draft is preserved.
         </p>
       )}
+    </>
+  );
+  return (
+    <Frame page={page}>
+      {page !== "configuration" && (
+        <div className="review-config-actions">
+          <Button
+            disabled={editing || !onNavigate}
+            onClick={() => void navigate("configuration")}
+          >
+            <ArrowLeftIcon /> Back to Review Configuration
+          </Button>
+        </div>
+      )}
+      {navigationError && <p role="alert">{navigationError}</p>}
+      {(page !== "configuration" || !channel) && channelSelector}
       {channel &&
         (page !== "configuration" ? (
           <ReviewSubmissions
@@ -300,6 +275,9 @@ export function ReviewConfigurationCommunity({
             channel={channel}
             writable={writable}
             onEditingChange={setEditing}
+            channelSelector={channelSelector}
+            onSubmit={onNavigate ? () => void navigate("submit") : undefined}
+            onOpenThread={onOpenThread}
           />
         ))}
     </Frame>
@@ -311,13 +289,21 @@ function ChannelConfiguration({
   channel,
   writable,
   onEditingChange,
+  channelSelector,
+  onSubmit,
+  onOpenThread,
 }: {
+  channelSelector: ReactNode;
+  onSubmit?: (() => void) | undefined;
+  onOpenThread?: ((channel: string, id: string) => Promise<void>) | undefined;
   session: RelaySession;
   channel: string;
   writable: boolean;
   onEditingChange: (editing: boolean) => void;
 }) {
   const choices = useAgentChoices(session, true, true);
+  const [reviewsBusy, setReviewsBusy] = useState(false);
+  const [expanded, setExpanded] = useState<string[]>([]);
   const [laneId, setLaneId] = useState<string>();
   const [rows, setRows] = useState<SavedReviewConfig[]>([]);
   const [loading, setLoading] = useState(true);
@@ -332,15 +318,17 @@ function ChannelConfiguration({
   const editorTrigger = useRef<HTMLElement | null>(null);
   const lanesRegion = useRef<HTMLElement | null>(null);
   useEffect(() => {
-    onEditingChange(editor !== undefined);
+    onEditingChange(editor !== undefined || reviewsBusy);
+    return () => onEditingChange(false);
+  }, [editor, reviewsBusy, onEditingChange]);
+  useEffect(() => {
     if (editor === undefined) {
       const trigger = editorTrigger.current;
       if (trigger?.isConnected && !trigger.matches(":disabled"))
         trigger.focus();
       else lanesRegion.current?.focus();
     }
-    return () => onEditingChange(false);
-  }, [editor, onEditingChange]);
+  }, [editor]);
   // biome-ignore lint/correctness/useExhaustiveDependencies: Reload explicitly requests a fresh snapshot.
   useEffect(() => {
     const controller = new AbortController();
@@ -400,17 +388,12 @@ function ChannelConfiguration({
     <>
       {!selected && editor !== "new" ? (
         <>
-          <InlineHeader title="Repositories" />
           <div className="review-config-actions">
-            <Button
-              disabled={loading}
-              onClick={() => setReload((value) => value + 1)}
-            >
-              Reload
-            </Button>
             <Button
               ref={editorTrigger}
-              disabled={loading || !!error || !writable || remaining <= 0}
+              disabled={
+                loading || !!error || !writable || remaining <= 0 || reviewsBusy
+              }
               onClick={(event) => {
                 editorTrigger.current = event.currentTarget;
                 setNotice("");
@@ -419,7 +402,22 @@ function ChannelConfiguration({
             >
               Register repository
             </Button>
+            <Button disabled={reviewsBusy || !onSubmit} onClick={onSubmit}>
+              Submit PR
+            </Button>
           </div>
+          {channelSelector}
+          <InlineHeader
+            title="Repositories"
+            actions={
+              <Button
+                disabled={loading || reviewsBusy}
+                onClick={() => setReload((value) => value + 1)}
+              >
+                Reload
+              </Button>
+            }
+          />
           {loading ? (
             <p role="status">Loading configurations…</p>
           ) : error ? (
@@ -429,6 +427,7 @@ function ChannelConfiguration({
               {rows.map((row) => (
                 <NavigationItem
                   key={row.artifactId}
+                  disabled={reviewsBusy}
                   aria-label={`Open ${row.config.repository}`}
                   multiline
                   label={
@@ -455,9 +454,33 @@ function ChannelConfiguration({
             </p>
           )}
           {warning && <p role="alert">{warning}</p>}
+          <Accordion
+            variant="settings"
+            value={expanded}
+            onValueChange={(next) => {
+              if (!reviewsBusy) setExpanded(next);
+            }}
+            items={[
+              {
+                value: "Pull requests",
+                title: "Pull requests",
+                content: (
+                  <ReviewSubmissions
+                    session={session}
+                    channel={channel}
+                    mode="all"
+                    writable={writable}
+                    onEditingChange={setReviewsBusy}
+                    onOpenThread={onOpenThread}
+                  />
+                ),
+              },
+            ]}
+          />
         </>
       ) : (
         <>
+          {channelSelector}
           {!editor && (
             <div>
               <Button
diff --git a/src/bundled/review-configuration/review-configuration.css b/src/bundled/review-configuration/review-configuration.css
index bb0a1fca89..ed43ff95e6 100644
--- a/src/bundled/review-configuration/review-configuration.css
+++ b/src/bundled/review-configuration/review-configuration.css
@@ -143,6 +143,7 @@
   padding-top: var(--space-3);
 }
 
-.review-config-content[data-review-page="all"] {
+.review-config-content[data-review-page="all"],
+.review-config-content[data-review-page="configuration"] {
   max-width: 72rem;
 }

From e3b4dee7066b26316fe4776f411e3ded19a05c13 Mon Sep 17 00:00:00 2001
From: Ravneet Arora <rarora@squareup.com>
Date: Thu, 12 Nov 2026 15:40:22 -0500
Subject: [PATCH 12/17] Open pull requests from a top action

Co-authored-by: maincourse <37ce551b493d4a998caf030929c47bce0b6a0e43f1178b3a63c4151d7c16b76e@buzz.block.builderlab.xyz>
Signed-off-by: Ravneet Arora <rarora@squareup.com>
---
 docs/buzz-help.md                             |  4 +-
 src/bundled/review-configuration/README.md    |  6 +--
 .../ReviewConfigurationPage.test.tsx          | 14 ++----
 .../ReviewConfigurationPage.tsx               | 48 +++++--------------
 .../ReviewSubmissions.tsx                     | 10 ++--
 5 files changed, 25 insertions(+), 57 deletions(-)

diff --git a/docs/buzz-help.md b/docs/buzz-help.md
index 7d3e3261c8..1f4d3c7cb7 100644
--- a/docs/buzz-help.md
+++ b/docs/buzz-help.md
@@ -1161,7 +1161,7 @@ confirmation. **Delete team** asks first; it doesn't delete the team's agents.
   reads the latest saved versions. Settings live on the community relay and are
   visible to channel readers; members who can post can edit them. A conflicting
   edit preserves your draft: copy your changes before cancelling and reloading.
-  **Review Configuration** has matching **Register repository** and **Submit PR** actions at the top, a **Repositories** section, and an expandable **Pull requests** table. **Edit lane**
+  **Review Configuration** has matching **Register repository**, **Submit PR**, and **Pull requests** actions at the top, followed by **Repositories**. **Edit lane**
   opens one lane; **Save lane** persists it before **Add lane** starts another.
   **Back to lanes** cancels the editor; **Back to repositories** returns to the list.
   Every new or edited lane requires at least one all/any routing rule matching
@@ -1171,7 +1171,7 @@ confirmation. **Delete team** asks first; it doesn't delete the team's agents.
   Submit button. It finds the repository in the selected review channel, reads
   current PR details, and assigns the first configured reviewer in each matching
   lane. Missing configuration or zero matching lanes sends nothing. Results show
-  assigned agents and their thread buttons. Expand **Pull requests** on the main page to see previous submissions in a bordered table. The original submitter can confirm **Delete** to remove a submission from the shared list; its conversations and GitHub PR remain. Deleting does not stop active reviews. Resubmitting restores its saved reviewers and threads.
+  assigned agents and their thread buttons. Choose **Pull requests** on the main page to see previous submissions in a bordered table. The original submitter can confirm **Delete** to remove a submission from the shared list; its conversations and GitHub PR remain. Deleting does not stop active reviews. Resubmitting restores its saved reviewers and threads.
   Submitting an existing PR reuses its saved reviewers and threads and mentions
   them again in those threads. Incomplete initial delivery resumes from the original
   browser profile. An interrupted notification retries its saved messages.
diff --git a/src/bundled/review-configuration/README.md b/src/bundled/review-configuration/README.md
index 0dd161ff06..505a3b419c 100644
--- a/src/bundled/review-configuration/README.md
+++ b/src/bundled/review-configuration/README.md
@@ -6,14 +6,14 @@ Choose a channel, register a GitHub repository, add named lanes, reviewer agents
 and save. Open a repository row to manage its lanes. Saved cards show agents,
 instructions, and routing rules. **Edit lane** opens one lane; **Save lane** persists
 it before another can be added. **Back to lanes** cancels edits; **Back to repositories**
-returns to the list. The main page has matching **Register repository** and **Submit PR** actions above the **Repositories** section and an expandable **Pull requests** table.
+returns to the list. The main page has matching **Register repository**, **Submit PR**, and **Pull requests** actions above the **Repositories** section.
 
 The **Submit PR** page has a full GitHub PR URL field and one
 Submit button. It finds the saved repository in the selected channel, loads current
 PR metadata, and assigns the first configured reviewer per matching lane. Missing
 configuration, unavailable reviewers, and zero matching lanes produce an error
 without starting threads. Results show assigned reviewers and thread buttons.
-The **Pull requests** section shows previous submissions in a bordered table with delivery status, reviewer identities, and thread links. The submitter can confirm **Delete** to remove a submission from the shared list. This preserves its thread mapping and does not stop active reviews, delete conversations, or close the GitHub PR. Submitting that URL again restores the saved assignment and threads.
+The separate **Pull requests** page shows previous submissions in a bordered table with delivery status, reviewer identities, and thread links. The submitter can confirm **Delete** to remove a submission from the shared list. This preserves its thread mapping and does not stop active reviews, delete conversations, or close the GitHub PR. Submitting that URL again restores the saved assignment and threads.
 
 Submitting an already-delivered PR sends a reviewer mention in each saved lane
 thread. It preserves the saved reviewers and instructions and creates no new
@@ -21,7 +21,7 @@ threads or review rounds. Incomplete original submissions resume delivery from
 the original browser profile instead. These actions run only on Submit; opening
 the page or a thread never dispatches messages.
 
-All three pages use the shell's page navigation. Only Review Configuration appears in the sidebar; Submit PR has a Back button returning to it. The existing All PRs route remains available for saved navigation. Repository and lane editing
+All three pages use the shell's page navigation. Only Review Configuration appears in the sidebar; Submit PR has a Back button returning to it. Pull requests opens the existing All PRs page with Back navigation. Repository and lane editing
 remain local sections; reloading returns Configuration to its repository list.
 The channel selection is remembered per identity/community; one eligible channel
 is selected automatically. Submit results can be recovered from the Pull requests table
diff --git a/src/bundled/review-configuration/ReviewConfigurationPage.test.tsx b/src/bundled/review-configuration/ReviewConfigurationPage.test.tsx
index 01a61f0d8a..5ad9130c31 100644
--- a/src/bundled/review-configuration/ReviewConfigurationPage.test.tsx
+++ b/src/bundled/review-configuration/ReviewConfigurationPage.test.tsx
@@ -658,7 +658,7 @@ it("returns focus to the lane region after removing the edited lane", async () =
   ).toEqual(["General"]);
 });
 
-it("expands the PR list on the home page without opening another page", async () => {
+it("opens the PR table from the home page action", async () => {
   const test = fixture();
   const onNavigate = vi.fn(async () => {});
   render(
@@ -670,16 +670,8 @@ it("expands the PR list on the home page without opening another page", async ()
   const user = userEvent.setup();
   await screen.findByRole("button", { name: "Register repository" });
   expect(screen.queryByRole("region", { name: "All PRs" })).toBeNull();
-  const disclosure = screen.getByRole("button", { name: "Pull requests" });
-  await user.click(disclosure);
-  await screen.findByText(
-    "No submissions in the list. Use Submit PR to start a review.",
-  );
-  expect(onNavigate).not.toHaveBeenCalled();
-  await user.click(disclosure);
-  await waitFor(() =>
-    expect(disclosure.getAttribute("aria-expanded")).toBe("false"),
-  );
+  await user.click(screen.getByRole("button", { name: "Pull requests" }));
+  expect(onNavigate).toHaveBeenCalledWith("all");
   await user.click(screen.getByRole("button", { name: "Submit PR" }));
   expect(onNavigate).toHaveBeenCalledWith("submit");
 });
diff --git a/src/bundled/review-configuration/ReviewConfigurationPage.tsx b/src/bundled/review-configuration/ReviewConfigurationPage.tsx
index a848bb5cf7..7913d02bba 100644
--- a/src/bundled/review-configuration/ReviewConfigurationPage.tsx
+++ b/src/bundled/review-configuration/ReviewConfigurationPage.tsx
@@ -16,7 +16,6 @@ import {
 } from "../../shared/design-system/icons";
 import { NavigationItem } from "../../shared/design-system/ui/NavigationItem";
 import { Button } from "../../shared/design-system/ui/Button";
-import { Accordion } from "../../shared/design-system/ui/Accordion";
 import { Field } from "../../shared/design-system/ui/Field";
 import { FullPageSurface } from "../../shared/design-system/ui/FullPageSurface";
 import { InlineHeader } from "../../shared/design-system/ui/Header";
@@ -277,7 +276,7 @@ export function ReviewConfigurationCommunity({
             onEditingChange={setEditing}
             channelSelector={channelSelector}
             onSubmit={onNavigate ? () => void navigate("submit") : undefined}
-            onOpenThread={onOpenThread}
+            onShowPulls={onNavigate ? () => void navigate("all") : undefined}
           />
         ))}
     </Frame>
@@ -291,19 +290,17 @@ function ChannelConfiguration({
   onEditingChange,
   channelSelector,
   onSubmit,
-  onOpenThread,
+  onShowPulls,
 }: {
   channelSelector: ReactNode;
   onSubmit?: (() => void) | undefined;
-  onOpenThread?: ((channel: string, id: string) => Promise<void>) | undefined;
+  onShowPulls?: (() => void) | undefined;
   session: RelaySession;
   channel: string;
   writable: boolean;
   onEditingChange: (editing: boolean) => void;
 }) {
   const choices = useAgentChoices(session, true, true);
-  const [reviewsBusy, setReviewsBusy] = useState(false);
-  const [expanded, setExpanded] = useState<string[]>([]);
   const [laneId, setLaneId] = useState<string>();
   const [rows, setRows] = useState<SavedReviewConfig[]>([]);
   const [loading, setLoading] = useState(true);
@@ -318,9 +315,9 @@ function ChannelConfiguration({
   const editorTrigger = useRef<HTMLElement | null>(null);
   const lanesRegion = useRef<HTMLElement | null>(null);
   useEffect(() => {
-    onEditingChange(editor !== undefined || reviewsBusy);
+    onEditingChange(editor !== undefined);
     return () => onEditingChange(false);
-  }, [editor, reviewsBusy, onEditingChange]);
+  }, [editor, onEditingChange]);
   useEffect(() => {
     if (editor === undefined) {
       const trigger = editorTrigger.current;
@@ -391,9 +388,7 @@ function ChannelConfiguration({
           <div className="review-config-actions">
             <Button
               ref={editorTrigger}
-              disabled={
-                loading || !!error || !writable || remaining <= 0 || reviewsBusy
-              }
+              disabled={loading || !!error || !writable || remaining <= 0}
               onClick={(event) => {
                 editorTrigger.current = event.currentTarget;
                 setNotice("");
@@ -402,16 +397,19 @@ function ChannelConfiguration({
             >
               Register repository
             </Button>
-            <Button disabled={reviewsBusy || !onSubmit} onClick={onSubmit}>
+            <Button disabled={!onSubmit} onClick={onSubmit}>
               Submit PR
             </Button>
+            <Button disabled={!onShowPulls} onClick={onShowPulls}>
+              Pull requests
+            </Button>
           </div>
           {channelSelector}
           <InlineHeader
             title="Repositories"
             actions={
               <Button
-                disabled={loading || reviewsBusy}
+                disabled={loading}
                 onClick={() => setReload((value) => value + 1)}
               >
                 Reload
@@ -427,7 +425,6 @@ function ChannelConfiguration({
               {rows.map((row) => (
                 <NavigationItem
                   key={row.artifactId}
-                  disabled={reviewsBusy}
                   aria-label={`Open ${row.config.repository}`}
                   multiline
                   label={
@@ -454,29 +451,6 @@ function ChannelConfiguration({
             </p>
           )}
           {warning && <p role="alert">{warning}</p>}
-          <Accordion
-            variant="settings"
-            value={expanded}
-            onValueChange={(next) => {
-              if (!reviewsBusy) setExpanded(next);
-            }}
-            items={[
-              {
-                value: "Pull requests",
-                title: "Pull requests",
-                content: (
-                  <ReviewSubmissions
-                    session={session}
-                    channel={channel}
-                    mode="all"
-                    writable={writable}
-                    onEditingChange={setReviewsBusy}
-                    onOpenThread={onOpenThread}
-                  />
-                ),
-              },
-            ]}
-          />
         </>
       ) : (
         <>
diff --git a/src/bundled/review-configuration/ReviewSubmissions.tsx b/src/bundled/review-configuration/ReviewSubmissions.tsx
index 0d0aed0e16..42b271a4d6 100644
--- a/src/bundled/review-configuration/ReviewSubmissions.tsx
+++ b/src/bundled/review-configuration/ReviewSubmissions.tsx
@@ -2,6 +2,8 @@ import { useEffect, useRef, useState } from "react";
 import { useAgentChoices } from "../../features/agents/use-choices";
 import type { RelaySession } from "../../features/relay/session";
 import { AlertDialog } from "../../shared/design-system/ui/AlertDialog";
+import { TrashIcon } from "../../shared/design-system/icons";
+import { IconButton } from "../../shared/design-system/ui/IconButton";
 import { Button } from "../../shared/design-system/ui/Button";
 import { Field } from "../../shared/design-system/ui/Field";
 import { InlineHeader } from "../../shared/design-system/ui/Header";
@@ -278,7 +280,9 @@ export function ReviewSubmissions({
                 <td>{threads(row)}</td>
                 {deletable && (
                   <td>
-                    <Button
+                    <IconButton
+                      icon={<TrashIcon />}
+                      title="Delete submission"
                       size="sm"
                       disabled={
                         busy ||
@@ -292,9 +296,7 @@ export function ReviewSubmissions({
                         setRemoving(row);
                       }}
                       aria-label={`Delete ${row.value.config.repository}#${row.value.pr}`}
-                    >
-                      Delete
-                    </Button>
+                    />
                     {row.value.submitter !== session.viewer && (
                       <p className="text-caption text-subtle">
                         Only the submitter can delete.

From 4cd30739828a0c666911efc2a9f476b8d7fc815d Mon Sep 17 00:00:00 2001
From: Ravneet Arora <rarora@squareup.com>
Date: Thu, 12 Nov 2026 15:54:17 -0500
Subject: [PATCH 13/17] Restart deleted reviews and add reviewer reminders

Co-authored-by: maincourse <37ce551b493d4a998caf030929c47bce0b6a0e43f1178b3a63c4151d7c16b76e@buzz.block.builderlab.xyz>
Signed-off-by: Ravneet Arora <rarora@squareup.com>
---
 docs/buzz-help.md                             |   2 +-
 src/bundled/review-configuration/README.md    |   3 +-
 .../ReviewSubmissions.test.tsx                |  65 +++++
 .../ReviewSubmissions.tsx                     |  87 +++++--
 .../review-configuration/submissions.test.ts  | 233 +++++++++++++++++-
 .../review-configuration/submissions.ts       |  97 ++++++--
 6 files changed, 442 insertions(+), 45 deletions(-)

diff --git a/docs/buzz-help.md b/docs/buzz-help.md
index 1f4d3c7cb7..c37e95e1bf 100644
--- a/docs/buzz-help.md
+++ b/docs/buzz-help.md
@@ -1171,7 +1171,7 @@ confirmation. **Delete team** asks first; it doesn't delete the team's agents.
   Submit button. It finds the repository in the selected review channel, reads
   current PR details, and assigns the first configured reviewer in each matching
   lane. Missing configuration or zero matching lanes sends nothing. Results show
-  assigned agents and their thread buttons. Choose **Pull requests** on the main page to see previous submissions in a bordered table. The original submitter can confirm **Delete** to remove a submission from the shared list; its conversations and GitHub PR remain. Deleting does not stop active reviews. Resubmitting restores its saved reviewers and threads.
+  assigned agents and their thread buttons. Choose **Pull requests** on the main page to see previous submissions in a bordered table. The original submitter can click **Remind** to notify assigned reviewers in their current threads, or confirm **Delete** to remove a submission from the shared list; its conversations and GitHub PR remain. Deleting does not stop active reviews. Resubmitting a deleted PR applies current routing and creates new reviewer threads.
   Submitting an existing PR reuses its saved reviewers and threads and mentions
   them again in those threads. Incomplete initial delivery resumes from the original
   browser profile. An interrupted notification retries its saved messages.
diff --git a/src/bundled/review-configuration/README.md b/src/bundled/review-configuration/README.md
index 505a3b419c..307d7f2628 100644
--- a/src/bundled/review-configuration/README.md
+++ b/src/bundled/review-configuration/README.md
@@ -13,7 +13,7 @@ Submit button. It finds the saved repository in the selected channel, loads curr
 PR metadata, and assigns the first configured reviewer per matching lane. Missing
 configuration, unavailable reviewers, and zero matching lanes produce an error
 without starting threads. Results show assigned reviewers and thread buttons.
-The separate **Pull requests** page shows previous submissions in a bordered table with delivery status, reviewer identities, and thread links. The submitter can confirm **Delete** to remove a submission from the shared list. This preserves its thread mapping and does not stop active reviews, delete conversations, or close the GitHub PR. Submitting that URL again restores the saved assignment and threads.
+The separate **Pull requests** page shows previous submissions in a bordered table with delivery status, reviewer identities, and thread links. The submitter can click **Remind** to notify saved reviewers in their current threads, with delivery feedback and retry on failure. Incomplete submissions must finish delivery through Submit PR first. The submitter can confirm **Delete** to remove a submission from the shared list. This does not stop active reviews, delete conversations, or close the GitHub PR. Submitting that URL again applies current routing and creates new reviewer threads.
 
 Submitting an already-delivered PR sends a reviewer mention in each saved lane
 thread. It preserves the saved reviewers and instructions and creates no new
@@ -23,6 +23,7 @@ the page or a thread never dispatches messages.
 
 All three pages use the shell's page navigation. Only Review Configuration appears in the sidebar; Submit PR has a Back button returning to it. Pull requests opens the existing All PRs page with Back navigation. Repository and lane editing
 remain local sections; reloading returns Configuration to its repository list.
+Restarted submissions use a versioned delivery generation; older plugin versions cannot read or resume them.
 The channel selection is remembered per identity/community; one eligible channel
 is selected automatically. Submit results can be recovered from the Pull requests table
 following reload; navigation never replays Submit automatically.
diff --git a/src/bundled/review-configuration/ReviewSubmissions.test.tsx b/src/bundled/review-configuration/ReviewSubmissions.test.tsx
index d1ef1fd0d0..bb85e53cc4 100644
--- a/src/bundled/review-configuration/ReviewSubmissions.test.tsx
+++ b/src/bundled/review-configuration/ReviewSubmissions.test.tsx
@@ -15,6 +15,7 @@ import { loadConfigurations, type SavedReviewConfig } from "./configuration";
 import {
   loadSubmissions,
   deleteSubmission,
+  remindSubmission,
   submitReview,
   type SavedSubmission,
 } from "./submissions";
@@ -27,6 +28,7 @@ vi.mock("./submissions", async (original) => ({
   ...(await original<typeof import("./submissions")>()),
   loadSubmissions: vi.fn(),
   deleteSubmission: vi.fn(),
+  remindSubmission: vi.fn(),
   submitReview: vi.fn(),
 }));
 afterEach(cleanup);
@@ -364,3 +366,66 @@ it("guards duplicate deletion and aborts it when leaving the page", async () =>
   expect(pending?.aborted).toBe(true);
   await act(async () => finish());
 });
+
+it("reminds from a row, guards duplicate clicks and reports success or failure", async () => {
+  vi.mocked(loadSubmissions).mockResolvedValue({ rows: [record], warning: "" });
+  let finish = () => {};
+  vi.mocked(remindSubmission).mockImplementationOnce(async () => {
+    await new Promise<void>((resolve) => {
+      finish = resolve;
+    });
+  });
+  const test = fixture("all");
+  const button = await screen.findByRole("button", {
+    name: "Remind reviewers for example-org/project#42",
+  });
+  await test.user.click(button);
+  expect(screen.getByRole("status").textContent).toContain(
+    "Reminding reviewers",
+  );
+  expect((button as HTMLButtonElement).disabled).toBe(true);
+  await test.user.click(button);
+  expect(remindSubmission).toHaveBeenCalledTimes(1);
+  await act(async () => finish());
+  expect(screen.getByRole("status").textContent).toContain(
+    "Reviewers reminded",
+  );
+  expect(remindSubmission).toHaveBeenCalledWith(
+    test.session,
+    "channel",
+    record,
+    expect.any(AbortSignal),
+  );
+  expect(submitReview).not.toHaveBeenCalled();
+  vi.mocked(remindSubmission).mockRejectedValueOnce(
+    new Error("Delivery failed"),
+  );
+  await test.user.click(button);
+  expect((await screen.findByRole("alert")).textContent).toContain(
+    "Delivery failed",
+  );
+  expect(screen.queryByRole("status")).toBeNull();
+});
+
+it("aborts pending reminders when leaving the page", async () => {
+  vi.mocked(loadSubmissions).mockResolvedValue({ rows: [record], warning: "" });
+  let finish = () => {};
+  let pending: AbortSignal | undefined;
+  vi.mocked(remindSubmission).mockImplementationOnce(
+    async (_s, _c, _r, signal) => {
+      pending = signal;
+      await new Promise<void>((resolve) => {
+        finish = resolve;
+      });
+    },
+  );
+  const test = fixture("all");
+  await test.user.click(
+    await screen.findByRole("button", {
+      name: "Remind reviewers for example-org/project#42",
+    }),
+  );
+  test.unmount();
+  expect(pending?.aborted).toBe(true);
+  await act(async () => finish());
+});
diff --git a/src/bundled/review-configuration/ReviewSubmissions.tsx b/src/bundled/review-configuration/ReviewSubmissions.tsx
index 42b271a4d6..1be2a30ba3 100644
--- a/src/bundled/review-configuration/ReviewSubmissions.tsx
+++ b/src/bundled/review-configuration/ReviewSubmissions.tsx
@@ -15,6 +15,7 @@ import { createPullReader, type ReadPull } from "./pull-facts";
 import {
   loadSubmissions,
   deleteSubmission,
+  remindSubmission,
   prUrl,
   pullRepository,
   pullRequest,
@@ -165,12 +166,44 @@ export function ReviewSubmissions({
     }
   }
 
+  async function remind(row: SavedSubmission) {
+    if (operation.current || !writable) return;
+    const controller = new AbortController();
+    operation.current = controller;
+    setBusy(true);
+    setError("");
+    const name = `${row.value.config.repository}#${row.value.pr}`;
+    setStatus(`Reminding reviewers for ${name}…`);
+    try {
+      await remindSubmission(
+        session,
+        channel,
+        row,
+        AbortSignal.any([controller.signal, AbortSignal.timeout(120_000)]),
+      );
+      if (!controller.signal.aborted)
+        setStatus(`Reviewers reminded for ${name} in their existing threads.`);
+    } catch (reason) {
+      if (!controller.signal.aborted) {
+        setStatus("");
+        setError(
+          `${reason instanceof Error ? reason.message : "Could not remind reviewers."} Unconfirmed reminders can be retried with Remind.`,
+        );
+      }
+    } finally {
+      operation.current = undefined;
+      if (!controller.signal.aborted) setBusy(false);
+    }
+  }
+
   async function remove() {
     if (!removing || operation.current || !writable) return;
     const controller = new AbortController();
     operation.current = controller;
     setBusy(true);
     setDeleteError("");
+    setError("");
+    setStatus("");
     try {
       await deleteSubmission(
         session,
@@ -280,26 +313,42 @@ export function ReviewSubmissions({
                 <td>{threads(row)}</td>
                 {deletable && (
                   <td>
-                    <IconButton
-                      icon={<TrashIcon />}
-                      title="Delete submission"
-                      size="sm"
-                      disabled={
-                        busy ||
-                        listLoading ||
-                        !writable ||
-                        row.value.submitter !== session.viewer
-                      }
-                      onClick={(event) => {
-                        deleteTrigger.current = event.currentTarget;
-                        setDeleteError("");
-                        setRemoving(row);
-                      }}
-                      aria-label={`Delete ${row.value.config.repository}#${row.value.pr}`}
-                    />
+                    <div className="review-config-actions">
+                      <Button
+                        size="sm"
+                        disabled={
+                          busy ||
+                          listLoading ||
+                          !writable ||
+                          row.value.submitter !== session.viewer ||
+                          !row.value.threads.every((thread) => thread.delivered)
+                        }
+                        aria-label={`Remind reviewers for ${row.value.config.repository}#${row.value.pr}`}
+                        onClick={() => void remind(row)}
+                      >
+                        Remind
+                      </Button>
+                      <IconButton
+                        icon={<TrashIcon />}
+                        title="Delete submission"
+                        size="sm"
+                        disabled={
+                          busy ||
+                          listLoading ||
+                          !writable ||
+                          row.value.submitter !== session.viewer
+                        }
+                        onClick={(event) => {
+                          deleteTrigger.current = event.currentTarget;
+                          setDeleteError("");
+                          setRemoving(row);
+                        }}
+                        aria-label={`Delete ${row.value.config.repository}#${row.value.pr}`}
+                      />
+                    </div>
                     {row.value.submitter !== session.viewer && (
                       <p className="text-caption text-subtle">
-                        Only the submitter can delete.
+                        Only the submitter can remind or delete.
                       </p>
                     )}
                   </td>
@@ -421,7 +470,7 @@ export function ReviewSubmissions({
       {removing && (
         <AlertDialog
           title={`Delete ${removing.value.config.repository}#${removing.value.pr}?`}
-          description="Remove this submission from the shared list. The GitHub PR and existing conversations stay available. This does not stop an active review. Submitting the same URL again restores its saved reviewers and threads."
+          description="Remove this submission from the shared list. The GitHub PR and existing conversations stay available. This does not stop an active review. Submitting the same URL again starts a new review with new threads."
           pending={busy}
           finalFocus={() =>
             deleteTrigger.current?.isConnected
diff --git a/src/bundled/review-configuration/submissions.test.ts b/src/bundled/review-configuration/submissions.test.ts
index 55f9f28d65..75d7862ac3 100644
--- a/src/bundled/review-configuration/submissions.test.ts
+++ b/src/bundled/review-configuration/submissions.test.ts
@@ -8,6 +8,7 @@ import { keypair, signed } from "../../features/relay/testing";
 import {
   loadSubmissions,
   deleteSubmission,
+  remindSubmission,
   pullRequest,
   pullRepository,
   submitReview,
@@ -646,7 +647,7 @@ it("retries a partially delivered notification batch with the same message ident
   expect((await test.run()).value.threads).toEqual(first.value.threads);
 });
 
-it("deletes from the shared list and restores the same threads on resubmission after reload", async () => {
+it("deletes from the shared list and starts fresh threads using current routing after reload", async () => {
   const f = await fixture();
   const record = await f.run();
   await deleteSubmission(
@@ -660,10 +661,56 @@ it("deletes from the shared list and restores the same threads on resubmission a
       .rows,
   ).toEqual([]);
   expect(f.messages.size).toBe(2);
-  const restored = await f.run("123", new AbortController().signal, true);
+  f.loseJournal();
+  const existing = vi.fn();
+  const facts = vi.fn(async () => ({
+    repository: "example-org/project",
+    pr: 123,
+    title: "Fresh review",
+    labels: [],
+    changedFiles: 1,
+    paths: ["backend.ts"],
+    head: "a".repeat(40),
+    base: "b".repeat(40),
+  }));
+  const lane = f.config.config.lanes[0];
+  if (!lane) throw new Error("Missing fixture lane");
+  const config = {
+    ...f.config,
+    config: {
+      ...f.config.config,
+      lanes: [
+        {
+          ...lane,
+          instructions: "New review instructions",
+        },
+      ],
+    },
+  };
+  const restored = await submitReview(
+    f.session,
+    channel,
+    config,
+    "123",
+    [f.agent.pubkey],
+    new AbortController().signal,
+    () => {},
+    true,
+    facts,
+    existing,
+  );
   expect(restored.value.deleted).toBeUndefined();
-  expect(restored.value.threads).toEqual(record.value.threads);
-  expect(f.messages.size).toBe(2);
+  expect(restored.value.version).toBe(3);
+  expect(restored.value.threads).toHaveLength(1);
+  expect(record.value.threads.map((t) => t.id)).not.toContain(
+    restored.value.threads[0]?.id,
+  );
+  expect(facts).toHaveBeenCalledOnce();
+  expect(existing).not.toHaveBeenCalled();
+  expect(f.messages.size).toBe(3);
+  const message = f.messages.get(restored.value.threads[0]?.id ?? "");
+  expect(message?.content).toContain("New review instructions");
+  expect(message?.tags.some((t) => t[0] === "e")).toBe(false);
   expect(
     (await loadSubmissions(f.session, channel, new AbortController().signal))
       .rows,
@@ -694,3 +741,181 @@ it("rejects foreign submitters and stale deletion without changing the saved lis
       .rows,
   ).toHaveLength(1);
 });
+
+it("isolates a fresh review from old receipts and resumes its own interrupted delivery", async () => {
+  const f = await fixture();
+  const original = f.session.outbox;
+  if (!original) throw new Error("Missing fixture outbox");
+  Object.assign(f.session, {
+    outbox: { ...original, acknowledge: async () => {} },
+  });
+  const first = await f.run();
+  await deleteSubmission(
+    f.session,
+    channel,
+    first,
+    new AbortController().signal,
+  );
+  Object.assign(f.session, { outbox: original });
+  f.publish.mockRejectedValueOnce(new Error("offline"));
+  await expect(f.run("123", undefined, true)).rejects.toThrow();
+  const incomplete = (
+    await loadSubmissions(f.session, channel, new AbortController().signal)
+  ).rows[0];
+  if (!incomplete) throw new Error("Missing incomplete submission");
+  expect(incomplete.value.threads[0]?.id).not.toBe(first.value.threads[0]?.id);
+  const resumed = await f.run("123", undefined, true);
+  expect(resumed.value.generation).toBe(incomplete.value.generation);
+  expect(resumed.value.threads[0]?.id).toBe(incomplete.value.threads[0]?.id);
+  expect(resumed.value.threads.every((t) => t.delivered)).toBe(true);
+  expect(f.messages.size).toBe(4);
+  await deleteSubmission(
+    f.session,
+    channel,
+    resumed,
+    new AbortController().signal,
+  );
+  const next = await f.run("123", undefined, true);
+  expect(next.value.generation).not.toBe(resumed.value.generation);
+  expect(f.messages.size).toBe(6);
+});
+
+it("does not send fresh threads when replacing a deleted record loses its revision race", async () => {
+  const f = await fixture();
+  const first = await f.run();
+  await deleteSubmission(
+    f.session,
+    channel,
+    first,
+    new AbortController().signal,
+  );
+  f.artifactPublish.mockRejectedValueOnce(new Error("stale revision"));
+  await expect(f.run("123", undefined, true)).rejects.toThrow("stale revision");
+  expect(f.messages.size).toBe(2);
+  expect(
+    (await loadSubmissions(f.session, channel, new AbortController().signal))
+      .rows,
+  ).toEqual([]);
+});
+
+it("refuses a foreign submitter replacing a deleted record", async () => {
+  const f = await fixture();
+  const first = await f.run();
+  await deleteSubmission(
+    f.session,
+    channel,
+    first,
+    new AbortController().signal,
+  );
+  await expect(
+    submitReview(
+      { ...f.session, viewer: keypair().pubkey },
+      channel,
+      f.config,
+      "123",
+      [f.agent.pubkey, f.agent.pubkey],
+      new AbortController().signal,
+      () => {},
+      true,
+    ),
+  ).rejects.toThrow("Only the original submitter");
+  expect(f.messages.size).toBe(2);
+});
+
+it("reminds saved reviewers without replacing threads or writing artifacts", async () => {
+  const test = await fixture();
+  const first = await test.run();
+  const writes = test.artifactPublish.mock.calls.length;
+  await remindSubmission(
+    test.session,
+    channel,
+    first,
+    new AbortController().signal,
+  );
+  const replies = [...test.messages.values()].filter((event) =>
+    event.tags.some((tag) => tag[0] === "e"),
+  );
+  expect(replies).toHaveLength(2);
+  for (const [index, reply] of replies.entries()) {
+    expect(reply.tags).toContainEqual([
+      "e",
+      first.value.threads[index]?.id,
+      "",
+      "reply",
+    ]);
+    expect(reply.tags).toContainEqual(["p", test.agent.pubkey]);
+    expect(reply.content).toContain("Review reminder.");
+  }
+  expect(test.artifactPublish).toHaveBeenCalledTimes(writes);
+  await deleteSubmission(
+    test.session,
+    channel,
+    first,
+    new AbortController().signal,
+  );
+  await expect(
+    remindSubmission(
+      test.session,
+      channel,
+      first,
+      new AbortController().signal,
+    ),
+  ).rejects.toThrow("Submission changed");
+  expect(test.publish).toHaveBeenCalledTimes(4);
+});
+
+it("retries interrupted reminder batches without duplicating accepted replies", async () => {
+  const test = await fixture();
+  const first = await test.run();
+  test.publish
+    .mockResolvedValueOnce(undefined)
+    .mockRejectedValueOnce(new Error("offline"));
+  await expect(
+    remindSubmission(
+      test.session,
+      channel,
+      first,
+      new AbortController().signal,
+    ),
+  ).rejects.toThrow("offline");
+  await remindSubmission(
+    test.session,
+    channel,
+    first,
+    new AbortController().signal,
+  );
+  const replies = [...test.messages.values()].filter((event) =>
+    event.tags.some((tag) => tag[0] === "e"),
+  );
+  // The first successful publish was stubbed; compare signed event IDs instead.
+  const sent = test.publish.mock.calls.slice(2).map(([event]) => event);
+  expect(sent).toHaveLength(3);
+  expect(sent[1]?.id).toBe(sent[2]?.id);
+  expect(sent[0]?.id).not.toBe(sent[1]?.id);
+  expect(replies).toHaveLength(1);
+});
+
+it("refuses reminders for incomplete delivery and other submitters", async () => {
+  const test = await fixture();
+  test.publish.mockRejectedValueOnce(new Error("offline"));
+  await expect(test.run()).rejects.toThrow("offline");
+  const { rows } = await loadSubmissions(
+    test.session,
+    channel,
+    new AbortController().signal,
+  );
+  const row = rows[0];
+  if (!row) throw new Error("Missing fixture submission");
+  await expect(
+    remindSubmission(test.session, channel, row, new AbortController().signal),
+  ).rejects.toThrow("Delivery is incomplete");
+  await expect(
+    remindSubmission(
+      { ...test.session, viewer: test.agent.pubkey },
+      channel,
+      row,
+      new AbortController().signal,
+    ),
+  ).rejects.toThrow("Only the original submitter");
+  expect(test.publish).toHaveBeenCalledTimes(1);
+});
diff --git a/src/bundled/review-configuration/submissions.ts b/src/bundled/review-configuration/submissions.ts
index 98a0750bb9..40b2ae9fbf 100644
--- a/src/bundled/review-configuration/submissions.ts
+++ b/src/bundled/review-configuration/submissions.ts
@@ -21,7 +21,8 @@ const HEX = /^[0-9a-f]{64}$/;
 const UUID = /^[0-9a-f-]{36}$/;
 type Thread = { id?: string; started?: true; delivered?: true };
 export type Submission = {
-  version: 1 | 2;
+  version: 1 | 2 | 3;
+  generation?: string;
   pr: number;
   config: ReviewConfig;
   configRevision: string;
@@ -88,7 +89,9 @@ async function decode(
   const value = JSON.parse(event.content) as Submission;
   const config = validateConfig(value.config);
   if (
-    (value.version !== 1 && value.version !== 2) ||
+    (value.version !== 1 && value.version !== 2 && value.version !== 3) ||
+    (value.version === 3 &&
+      (typeof value.generation !== "string" || !UUID.test(value.generation))) ||
     !Number.isSafeInteger(value.pr) ||
     value.pr < 1 ||
     value.submitter !== event.pubkey ||
@@ -188,7 +191,7 @@ async function write(
   return { value, artifactId, revision: event.id };
 }
 
-/** Remove from the shared list, retaining recovery and thread identity for resubmission. */
+/** Remove from the shared list. A later submission creates fresh lane threads. */
 export async function deleteSubmission(
   session: RelaySession,
   channel: string,
@@ -367,6 +370,7 @@ async function notifyReviewers(
   channel: string,
   record: SavedSubmission,
   signal: AbortSignal,
+  reminder = false,
 ) {
   const outbox = session.outbox;
   if (!outbox) throw new Error("Message delivery is unavailable.");
@@ -404,7 +408,7 @@ async function notifyReviewers(
             ["e", thread.id, "", "reply"],
             ["p", lane.reviewers[0] ?? ""],
           ],
-          content: `This PR was submitted again. Please revisit the review in this thread.\n\n${request.content}`,
+          content: `${reminder ? "Review reminder. Please review this PR and report your progress or blockers in this thread." : "This PR was submitted again. Please revisit the review in this thread."}\n\n${request.content}`,
         },
         { key, value: record.artifactId },
         active,
@@ -416,6 +420,56 @@ async function notifyReviewers(
   for (const id of receipts) await outbox.acknowledge(id);
 }
 
+/** An explicit reminder uses only the current, fully delivered submission. */
+export async function remindSubmission(
+  session: RelaySession,
+  channel: string,
+  previous: SavedSubmission,
+  signal: AbortSignal,
+) {
+  const read = session.snapshotRead;
+  const outbox = session.outbox;
+  if (!read || !outbox?.supports(9) || !navigator.locks)
+    throw new Error("Reviewer reminders are unavailable on this client.");
+  if (!session.viewer || previous.value.submitter !== session.viewer)
+    throw new Error("Only the original submitter can remind these reviewers.");
+  return navigator.locks.request(
+    `buzz.review.submit:${session.scope}`,
+    { signal },
+    async () => {
+      await outbox.ready();
+      const events = await read(
+        [
+          {
+            kinds: [ARTIFACT_KIND],
+            "#h": [channel],
+            "#d": [previous.artifactId],
+            artifact: "current",
+            limit: 1,
+          },
+        ],
+        { signal },
+      );
+      const head = events[0];
+      if (!head) throw new Error("Submission is unavailable. Reload the list.");
+      const current = await decode(head, channel);
+      if (current.revision !== previous.revision || current.value.deleted)
+        throw new Error(
+          "Submission changed. Reload the list before reminding.",
+        );
+      if (current.value.submitter !== session.viewer)
+        throw new Error(
+          "Only the original submitter can remind these reviewers.",
+        );
+      if (!current.value.threads.every((thread) => thread.delivered))
+        throw new Error(
+          "Delivery is incomplete. Submit this PR again to finish delivery first.",
+        );
+      await notifyReviewers(session, channel, current, signal, true);
+    },
+  );
+}
+
 /** Explicit user action only. There is no background dispatcher or polling. */
 export async function submitReview(
   session: RelaySession,
@@ -459,10 +513,16 @@ export async function submitReview(
       );
       let record: SavedSubmission;
       const head = events[0];
-      if (head) {
-        record = await decode(head, channel);
+      const previous = head ? await decode(head, channel) : undefined;
+      const existing = previous && !previous.value.deleted;
+      if (existing) {
+        record = previous;
         notifyExisting?.();
       } else {
+        if (previous && previous.value.submitter !== viewer)
+          throw new Error(
+            "Only the original submitter can resubmit this deleted submission.",
+          );
         const currentFacts =
           typeof facts === "function" ? await facts() : facts;
         signal.throwIfAborted();
@@ -496,7 +556,8 @@ export async function submitReview(
           }),
         });
         const value: Submission = {
-          version: 2,
+          version: previous ? 3 : 2,
+          ...(previous ? { generation: crypto.randomUUID() } : {}),
           pr,
           config,
           configRevision: saved.revision,
@@ -505,21 +566,13 @@ export async function submitReview(
           threads: Array.from({ length: config.lanes.length }, () => ({})),
         };
         await eligible(session, value, signal);
-        record = await write(session, channel, value, undefined, signal);
-      }
-      if (record.value.deleted && (resume || notifyExisting)) {
-        if (record.value.submitter !== session.viewer)
-          throw new Error(
-            "Only the original submitter can restore this deleted submission.",
-          );
-        const { deleted: _deleted, ...value } = record.value;
-        record = await write(session, channel, value, record, signal);
+        record = await write(session, channel, value, previous, signal);
       }
       onProgress(record);
       // The dedicated Submit action may notify; passive readers never dispatch.
-      if (head && !resume && !notifyExisting) return record;
+      if (existing && !resume && !notifyExisting) return record;
       if (record.value.threads.every((thread) => thread.delivered)) {
-        if (head && notifyExisting)
+        if (existing && notifyExisting)
           await notifyReviewers(session, channel, record, signal);
         for (const thread of record.value.threads)
           if (thread.id) await outbox.acknowledge(thread.id);
@@ -532,10 +585,14 @@ export async function submitReview(
         throw new Error(
           "This PR is already submitted. Resume incomplete delivery from the original browser profile; existing threads remain available here.",
         );
-      if (head) await eligible(session, record.value, signal);
+      if (existing) await eligible(session, record.value, signal);
       for (const [index, thread] of record.value.threads.entries()) {
         signal.throwIfAborted();
-        const key = `${artifactId}:${index}`;
+        // Keep legacy recovery keys readable, but isolate each post-delete review.
+        const key =
+          record.value.version === 3
+            ? `${artifactId}:${record.value.generation}:${index}`
+            : `${artifactId}:${index}`;
         if (thread.delivered) {
           if (thread.id) await outbox.acknowledge(thread.id);
           continue;

From b19ed8f4aef05d7f03f6473f1c2da0672da3d3f9 Mon Sep 17 00:00:00 2001
From: Ravneet Arora <rarora@squareup.com>
Date: Thu, 12 Nov 2026 16:02:24 -0500
Subject: [PATCH 14/17] Show PR status and stop reminders for closed reviews

Co-authored-by: maincourse <37ce551b493d4a998caf030929c47bce0b6a0e43f1178b3a63c4151d7c16b76e@buzz.block.builderlab.xyz>
Signed-off-by: Ravneet Arora <rarora@squareup.com>
---
 docs/buzz-help.md                             |   2 +-
 src/bundled/review-configuration/README.md    |   2 +-
 .../ReviewConfigurationPage.tsx               |  14 ++-
 .../ReviewSubmissions.test.tsx                |  76 +++++++++++++
 .../ReviewSubmissions.tsx                     |  93 +++++++++++++++-
 src/bundled/review-configuration/index.tsx    |   7 +-
 .../review-configuration/pull-facts.test.ts   |  58 +++++++++-
 .../review-configuration/pull-facts.ts        | 105 +++++++++++++++---
 .../review-configuration/submissions.test.ts  |  54 ++++++++-
 .../review-configuration/submissions.ts       |  12 ++
 10 files changed, 396 insertions(+), 27 deletions(-)

diff --git a/docs/buzz-help.md b/docs/buzz-help.md
index c37e95e1bf..28ff6f50e0 100644
--- a/docs/buzz-help.md
+++ b/docs/buzz-help.md
@@ -1171,7 +1171,7 @@ confirmation. **Delete team** asks first; it doesn't delete the team's agents.
   Submit button. It finds the repository in the selected review channel, reads
   current PR details, and assigns the first configured reviewer in each matching
   lane. Missing configuration or zero matching lanes sends nothing. Results show
-  assigned agents and their thread buttons. Choose **Pull requests** on the main page to see previous submissions in a bordered table. The original submitter can click **Remind** to notify assigned reviewers in their current threads, or confirm **Delete** to remove a submission from the shared list; its conversations and GitHub PR remain. Deleting does not stop active reviews. Resubmitting a deleted PR applies current routing and creates new reviewer threads.
+  assigned agents and their thread buttons. Choose **Pull requests** on the main page to see previous submissions in a bordered table. The table shows GitHub status (Open, Draft, Closed, or Merged); Reload refreshes it. Remind is disabled for closed, merged, loading, or unavailable PRs and rechecks GitHub before sending. The original submitter can click **Remind** to notify assigned reviewers in their current threads, or confirm **Delete** to remove a submission from the shared list; its conversations and GitHub PR remain. Deleting does not stop active reviews. Resubmitting a deleted PR applies current routing and creates new reviewer threads.
   Submitting an existing PR reuses its saved reviewers and threads and mentions
   them again in those threads. Incomplete initial delivery resumes from the original
   browser profile. An interrupted notification retries its saved messages.
diff --git a/src/bundled/review-configuration/README.md b/src/bundled/review-configuration/README.md
index 307d7f2628..ea8e6bef55 100644
--- a/src/bundled/review-configuration/README.md
+++ b/src/bundled/review-configuration/README.md
@@ -13,7 +13,7 @@ Submit button. It finds the saved repository in the selected channel, loads curr
 PR metadata, and assigns the first configured reviewer per matching lane. Missing
 configuration, unavailable reviewers, and zero matching lanes produce an error
 without starting threads. Results show assigned reviewers and thread buttons.
-The separate **Pull requests** page shows previous submissions in a bordered table with delivery status, reviewer identities, and thread links. The submitter can click **Remind** to notify saved reviewers in their current threads, with delivery feedback and retry on failure. Incomplete submissions must finish delivery through Submit PR first. The submitter can confirm **Delete** to remove a submission from the shared list. This does not stop active reviews, delete conversations, or close the GitHub PR. Submitting that URL again applies current routing and creates new reviewer threads.
+The separate **Pull requests** page shows previous submissions in a bordered table with delivery status, reviewer identities, and thread links. The table shows GitHub status (Open, Draft, Closed, or Merged); Reload refreshes it. Remind is disabled for closed, merged, loading, or unavailable PRs and rechecks GitHub before sending. The submitter can click **Remind** to notify saved reviewers in their current threads, with delivery feedback and retry on failure. Incomplete submissions must finish delivery through Submit PR first. The submitter can confirm **Delete** to remove a submission from the shared list. This does not stop active reviews, delete conversations, or close the GitHub PR. Submitting that URL again applies current routing and creates new reviewer threads.
 
 Submitting an already-delivered PR sends a reviewer mention in each saved lane
 thread. It preserves the saved reviewers and instructions and creates no new
diff --git a/src/bundled/review-configuration/ReviewConfigurationPage.tsx b/src/bundled/review-configuration/ReviewConfigurationPage.tsx
index 7913d02bba..ee07c50a3b 100644
--- a/src/bundled/review-configuration/ReviewConfigurationPage.tsx
+++ b/src/bundled/review-configuration/ReviewConfigurationPage.tsx
@@ -1,5 +1,11 @@
-import { createPullReader, type ReadPull } from "./pull-facts";
+import {
+  createPullReader,
+  createPullStatusReader,
+  type ReadPull,
+  type ReadPullStatus,
+} from "./pull-facts";
 const publicPullReader = createPullReader();
+const publicStatusReader = createPullStatusReader();
 import { LaneRules, ruleDescription } from "./LaneRules";
 import { useEffect, useRef, useState, type ReactNode } from "react";
 import { useAgentChoices } from "../../features/agents/use-choices";
@@ -73,12 +79,14 @@ export function ReviewConfigurationPage({
   relay,
   navigator,
   readPull = publicPullReader,
+  readStatus = publicStatusReader,
   page = "configuration",
 }: {
   page?: ReviewPage;
   relay: RelayData;
   navigator?: Navigation;
   readPull?: ReadPull;
+  readStatus?: ReadPullStatus;
 }) {
   const connection = useRelayConnection(relay);
   if (connection.status === "ready")
@@ -88,6 +96,7 @@ export function ReviewConfigurationPage({
         session={connection.session}
         page={page}
         readPull={readPull}
+        readStatus={readStatus}
         onNavigate={
           navigator
             ? async (page) => {
@@ -143,11 +152,13 @@ export function ReviewConfigurationCommunity({
   onOpenThread,
   onNavigate,
   readPull = publicPullReader,
+  readStatus = publicStatusReader,
   page = "configuration",
 }: {
   session: RelaySession;
   page?: ReviewPage;
   readPull?: ReadPull;
+  readStatus?: ReadPullStatus;
   onNavigate?: ((page: ReviewPage) => Promise<void>) | undefined;
   onOpenThread?: ((channel: string, id: string) => Promise<void>) | undefined;
 }) {
@@ -266,6 +277,7 @@ export function ReviewConfigurationCommunity({
             onEditingChange={setEditing}
             onOpenThread={onOpenThread}
             readPull={readPull}
+            readStatus={readStatus}
           />
         ) : (
           <ChannelConfiguration
diff --git a/src/bundled/review-configuration/ReviewSubmissions.test.tsx b/src/bundled/review-configuration/ReviewSubmissions.test.tsx
index bb85e53cc4..88924211ca 100644
--- a/src/bundled/review-configuration/ReviewSubmissions.test.tsx
+++ b/src/bundled/review-configuration/ReviewSubmissions.test.tsx
@@ -10,6 +10,7 @@ import {
 import userEvent from "@testing-library/user-event";
 import { afterEach, beforeEach, expect, it, vi } from "vitest";
 import type { RelaySession } from "../../features/relay/session";
+import type { ReadPullStatus } from "./pull-facts";
 import { ReviewSubmissions } from "./ReviewSubmissions";
 import { loadConfigurations, type SavedReviewConfig } from "./configuration";
 import {
@@ -82,6 +83,7 @@ beforeEach(() => {
 function fixture(
   mode: "submit" | "all" = "submit",
   viewer = record.value.submitter,
+  readStatus: ReadPullStatus = vi.fn(async () => "Open" as const),
 ) {
   const agents = [{ pubkey: "a".repeat(64), name: "UI Reviewer" }];
   const choices = {
@@ -120,12 +122,14 @@ function fixture(
       onEditingChange={editing}
       onOpenThread={onOpenThread}
       readPull={readPull}
+      readStatus={readStatus}
     />,
   );
   return {
     ...view,
     session,
     readPull,
+    readStatus,
     onOpenThread,
     editing,
     user: userEvent.setup(),
@@ -395,6 +399,7 @@ it("reminds from a row, guards duplicate clicks and reports success or failure",
     "channel",
     record,
     expect.any(AbortSignal),
+    expect.any(Function),
   );
   expect(submitReview).not.toHaveBeenCalled();
   vi.mocked(remindSubmission).mockRejectedValueOnce(
@@ -429,3 +434,74 @@ it("aborts pending reminders when leaving the page", async () => {
   expect(pending?.aborted).toBe(true);
   await act(async () => finish());
 });
+
+it.each(["Closed", "Merged", "Draft", "Open"] as const)(
+  "shows %s and enables Remind only for open PRs",
+  async (status) => {
+    vi.mocked(loadSubmissions).mockResolvedValue({
+      rows: [record],
+      warning: "",
+    });
+    fixture("all", record.value.submitter, async () => status);
+    await screen.findByRole("cell", { name: status });
+    const button = screen.getByRole("button", {
+      name: "Remind reviewers for example-org/project#42",
+    }) as HTMLButtonElement;
+    expect(button.disabled).toBe(status === "Closed" || status === "Merged");
+  },
+);
+
+it("keeps Remind disabled while loading or unavailable and refreshes status on Reload", async () => {
+  vi.mocked(loadSubmissions).mockImplementation(async () => ({
+    rows: [record],
+    warning: "",
+  }));
+  let reject = (_error: Error) => {};
+  const readStatus = vi
+    .fn<ReadPullStatus>()
+    .mockImplementationOnce(
+      () =>
+        new Promise((_resolve, fail) => {
+          reject = fail;
+        }),
+    )
+    .mockResolvedValue("Open");
+  const test = fixture("all", record.value.submitter, readStatus);
+  const button = (await screen.findByRole("button", {
+    name: "Remind reviewers for example-org/project#42",
+  })) as HTMLButtonElement;
+  expect(button.disabled).toBe(true);
+  await act(async () => reject(new Error("GitHub unavailable")));
+  await screen.findByRole("cell", { name: "Unavailable" });
+  expect(button.disabled).toBe(true);
+  await test.user.click(screen.getByRole("button", { name: "Reload" }));
+  await screen.findByRole("cell", { name: "Open" });
+  expect(button.disabled).toBe(false);
+});
+
+it("limits status reads and aborts queued work when leaving the list", async () => {
+  const rows = Array.from({ length: 6 }, (_, index) => ({
+    ...record,
+    artifactId: `submission-${index}`,
+    revision: `revision-${index}`,
+    value: { ...record.value, pr: index + 1 },
+  }));
+  vi.mocked(loadSubmissions).mockResolvedValue({ rows, warning: "" });
+  const signals: AbortSignal[] = [];
+  const finish: (() => void)[] = [];
+  const readStatus = vi.fn<ReadPullStatus>(async (_repo, _pr, signal) => {
+    signals.push(signal);
+    await new Promise<void>((resolve) => {
+      finish.push(resolve);
+    });
+    return "Open";
+  });
+  const test = fixture("all", record.value.submitter, readStatus);
+  await waitFor(() => expect(readStatus).toHaveBeenCalledTimes(4));
+  test.unmount();
+  expect(signals.every((signal) => signal.aborted)).toBe(true);
+  await act(async () => {
+    for (const resolve of finish) resolve();
+  });
+  expect(readStatus).toHaveBeenCalledTimes(4);
+});
diff --git a/src/bundled/review-configuration/ReviewSubmissions.tsx b/src/bundled/review-configuration/ReviewSubmissions.tsx
index 1be2a30ba3..c874de32b7 100644
--- a/src/bundled/review-configuration/ReviewSubmissions.tsx
+++ b/src/bundled/review-configuration/ReviewSubmissions.tsx
@@ -11,7 +11,13 @@ import { LoadingRegion } from "../../shared/design-system/ui/LoadingRegion";
 import { Input } from "../../shared/design-system/ui/Input";
 import { ReviewerIdentity } from "./LaneReviewers";
 import { loadConfigurations } from "./configuration";
-import { createPullReader, type ReadPull } from "./pull-facts";
+import {
+  createPullReader,
+  createPullStatusReader,
+  type PullStatus,
+  type ReadPullStatus,
+  type ReadPull,
+} from "./pull-facts";
 import {
   loadSubmissions,
   deleteSubmission,
@@ -25,6 +31,7 @@ import {
 } from "./submissions";
 
 const publicPullReader = createPullReader();
+const publicStatusReader = createPullStatusReader();
 
 export function ReviewSubmissions({
   session,
@@ -34,6 +41,7 @@ export function ReviewSubmissions({
   onEditingChange,
   onOpenThread,
   readPull = publicPullReader,
+  readStatus = publicStatusReader,
 }: {
   session: RelaySession;
   mode?: "submit" | "all";
@@ -42,6 +50,7 @@ export function ReviewSubmissions({
   onEditingChange: (editing: boolean) => void;
   onOpenThread?: ((channel: string, id: string) => Promise<void>) | undefined;
   readPull?: ReadPull;
+  readStatus?: ReadPullStatus;
 }) {
   const choices = useAgentChoices(session, true, true);
   const [pr, setPr] = useState("");
@@ -50,6 +59,9 @@ export function ReviewSubmissions({
   const [status, setStatus] = useState("");
   const [result, setResult] = useState<SavedSubmission>();
   const [rows, setRows] = useState<SavedSubmission[]>([]);
+  const [statuses, setStatuses] = useState<
+    Record<string, { value: PullStatus | "Unavailable"; error?: string }>
+  >({});
   const input = useRef<HTMLInputElement>(null);
   const listHeading = useRef<HTMLDivElement>(null);
   const deleteTrigger = useRef<HTMLButtonElement | null>(null);
@@ -95,6 +107,47 @@ export function ReviewSubmissions({
     return () => controller.abort();
   }, [session, channel, reload, mode]);
 
+  useEffect(() => {
+    if (mode !== "all") return;
+    const controller = new AbortController();
+    setStatuses({});
+    let next = 0;
+    async function worker() {
+      while (!controller.signal.aborted) {
+        const row = rows[next++];
+        if (!row) return;
+        try {
+          const value = await readStatus(
+            row.value.config.repository,
+            row.value.pr,
+            AbortSignal.any([controller.signal, AbortSignal.timeout(20_000)]),
+          );
+          if (!controller.signal.aborted)
+            setStatuses((current) => ({
+              ...current,
+              [row.revision]: { value },
+            }));
+        } catch (reason) {
+          if (!controller.signal.aborted)
+            setStatuses((current) => ({
+              ...current,
+              [row.revision]: {
+                value: "Unavailable",
+                error:
+                  reason instanceof Error
+                    ? reason.message
+                    : "Could not read PR status.",
+              },
+            }));
+        }
+      }
+    }
+    // Limit GitHub/desktop work when the bounded saved list contains many PRs.
+    for (let index = 0; index < Math.min(rows.length, 4); index++)
+      void worker();
+    return () => controller.abort();
+  }, [rows, mode, readStatus]);
+
   async function submit() {
     if (operation.current || !writable) return;
     const controller = new AbortController();
@@ -180,6 +233,24 @@ export function ReviewSubmissions({
         channel,
         row,
         AbortSignal.any([controller.signal, AbortSignal.timeout(120_000)]),
+        async (repository, pr, signal) => {
+          try {
+            const value = await readStatus(repository, pr, signal);
+            if (!controller.signal.aborted)
+              setStatuses((current) => ({
+                ...current,
+                [row.revision]: { value },
+              }));
+            return value;
+          } catch (reason) {
+            if (!controller.signal.aborted)
+              setStatuses((current) => ({
+                ...current,
+                [row.revision]: { value: "Unavailable" },
+              }));
+            throw reason;
+          }
+        },
       );
       if (!controller.signal.aborted)
         setStatus(`Reviewers reminded for ${name} in their existing threads.`);
@@ -187,7 +258,7 @@ export function ReviewSubmissions({
       if (!controller.signal.aborted) {
         setStatus("");
         setError(
-          `${reason instanceof Error ? reason.message : "Could not remind reviewers."} Unconfirmed reminders can be retried with Remind.`,
+          `${reason instanceof Error ? reason.message : "Could not remind reviewers."} Reload to refresh PR status; use Remind to retry unconfirmed delivery when available.`,
         );
       }
     } finally {
@@ -292,6 +363,7 @@ export function ReviewSubmissions({
           <thead>
             <tr>
               <th scope="col">Pull request</th>
+              {deletable && <th scope="col">Status</th>}
               <th scope="col">Delivery</th>
               <th scope="col">Reviewers &amp; threads</th>
               {deletable && <th scope="col">Actions</th>}
@@ -305,6 +377,11 @@ export function ReviewSubmissions({
                     {row.value.config.repository}#{row.value.pr}
                   </a>
                 </th>
+                {deletable && (
+                  <td title={statuses[row.revision]?.error}>
+                    {statuses[row.revision]?.value ?? "Loading…"}
+                  </td>
+                )}
                 <td>
                   {row.value.threads.every((thread) => thread.delivered)
                     ? "Requests delivered"
@@ -321,6 +398,9 @@ export function ReviewSubmissions({
                           listLoading ||
                           !writable ||
                           row.value.submitter !== session.viewer ||
+                          !["Open", "Draft"].includes(
+                            statuses[row.revision]?.value ?? "",
+                          ) ||
                           !row.value.threads.every((thread) => thread.delivered)
                         }
                         aria-label={`Remind reviewers for ${row.value.config.repository}#${row.value.pr}`}
@@ -439,6 +519,7 @@ export function ReviewSubmissions({
                   disabled={busy || listLoading || !!removing}
                   onClick={() => {
                     setStatus("");
+                    setError("");
                     setReload((value) => value + 1);
                   }}
                 >
@@ -464,6 +545,14 @@ export function ReviewSubmissions({
           {listError && (
             <p role="alert">{listError} Use Reload to try again.</p>
           )}
+          {Object.values(statuses).some(
+            (status) => status.value === "Unavailable",
+          ) && (
+            <p role="alert">
+              Some GitHub statuses could not be loaded. Remind is disabled for
+              those PRs. Use Reload to try again.
+            </p>
+          )}
           {warning && <p role="alert">{warning}</p>}
         </section>
       )}
diff --git a/src/bundled/review-configuration/index.tsx b/src/bundled/review-configuration/index.tsx
index 82113be88b..631c0459ea 100644
--- a/src/bundled/review-configuration/index.tsx
+++ b/src/bundled/review-configuration/index.tsx
@@ -1,5 +1,5 @@
 import { gitHubCli } from "../github/gh";
-import { createPullReader } from "./pull-facts";
+import { createPullReader, createPullStatusReader } from "./pull-facts";
 import type { PluginModule } from "../../plugins/api";
 import {
   ReviewConfigurationPage,
@@ -10,7 +10,9 @@ import {
 export const inject = ["pages", "relay", "navigation", "host"];
 export const apply: PluginModule["apply"] = (ctx) => {
   const { relay, navigation: navigator } = ctx;
-  const readPull = createPullReader(gitHubCli(ctx.host));
+  const gh = gitHubCli(ctx.host);
+  const readPull = createPullReader(gh);
+  const readStatus = createPullStatusReader(gh);
   for (const page of ["configuration", "submit", "all"] satisfies ReviewPage[])
     ctx.pages.register({
       id: page,
@@ -24,6 +26,7 @@ export const apply: PluginModule["apply"] = (ctx) => {
           relay={relay}
           navigator={navigator}
           readPull={readPull}
+          readStatus={readStatus}
         />
       ),
     });
diff --git a/src/bundled/review-configuration/pull-facts.test.ts b/src/bundled/review-configuration/pull-facts.test.ts
index 2912cbad08..b79e2d5fc0 100644
--- a/src/bundled/review-configuration/pull-facts.test.ts
+++ b/src/bundled/review-configuration/pull-facts.test.ts
@@ -1,5 +1,5 @@
 import { afterEach, expect, it, vi } from "vitest";
-import { createPullReader } from "./pull-facts";
+import { createPullReader, createPullStatusReader } from "./pull-facts";
 import { GhUnavailable, type GitHubCli } from "../github/gh";
 const signal = () => new AbortController().signal;
 const repository = "example-org/project";
@@ -119,3 +119,59 @@ it("stops at API errors, cancellation and the file limit", async () => {
   ).rejects.toThrow();
   expect(fetcher).toHaveBeenCalledTimes(2);
 });
+
+it.each([
+  ["OPEN", false, "Open"],
+  ["OPEN", true, "Draft"],
+  ["CLOSED", false, "Closed"],
+  ["MERGED", false, "Merged"],
+])(
+  "reads GitHub status %s without loading file pages",
+  async (state, isDraft, expected) => {
+    const gh = vi
+      .fn()
+      .mockResolvedValue({ repository: { pullRequest: { state, isDraft } } });
+    expect(
+      await createPullStatusReader(gh as GitHubCli)(repository, 12, signal()),
+    ).toBe(expected);
+    expect(gh).toHaveBeenCalledTimes(1);
+    expect(gh.mock.calls[0]?.[0]).not.toContain("files(");
+  },
+);
+
+it.each([
+  ["open", false, false, "Open"],
+  ["open", true, false, "Draft"],
+  ["closed", false, false, "Closed"],
+  ["closed", false, true, "Merged"],
+])(
+  "reads public lifecycle status and falls back only when gh is unavailable",
+  async (state, draft, merged, expected) => {
+    const fetcher = vi
+      .fn()
+      .mockResolvedValue(Response.json({ state, draft, merged }));
+    vi.stubGlobal("fetch", fetcher);
+    const gh = vi.fn().mockRejectedValue(new GhUnavailable("browser"));
+    expect(
+      await createPullStatusReader(gh as GitHubCli)(repository, 12, signal()),
+    ).toBe(expected);
+    expect(fetcher).toHaveBeenCalledTimes(1);
+  },
+);
+
+it("rejects unavailable or invalid status and never falls back on authenticated failures", async () => {
+  const fetcher = vi
+    .fn()
+    .mockResolvedValue(
+      Response.json({ state: "mystery", draft: false, merged: false }),
+    );
+  vi.stubGlobal("fetch", fetcher);
+  await expect(
+    createPullStatusReader()(repository, 12, signal()),
+  ).rejects.toThrow("unknown PR status");
+  const gh = vi.fn().mockRejectedValue(new Error("GitHub denied access"));
+  await expect(
+    createPullStatusReader(gh as GitHubCli)(repository, 12, signal()),
+  ).rejects.toThrow("denied access");
+  expect(fetcher).toHaveBeenCalledTimes(1);
+});
diff --git a/src/bundled/review-configuration/pull-facts.ts b/src/bundled/review-configuration/pull-facts.ts
index 0e5ce18f65..eaccf9773c 100644
--- a/src/bundled/review-configuration/pull-facts.ts
+++ b/src/bundled/review-configuration/pull-facts.ts
@@ -125,24 +125,8 @@ async function graphql(
 }
 async function publicRead(repository: string, pr: number, signal: AbortSignal) {
   const endpoint = `https://api.github.com/repos/${repository}/pulls/${pr}`;
-  async function read(url: string) {
-    const response = await fetch(url, {
-      signal,
-      credentials: "omit",
-      headers: { Accept: "application/vnd.github+json" },
-    });
-    if (!response.ok)
-      throw new Error(
-        response.status === 404
-          ? "This PR is private or unavailable. Use the desktop app with gh signed in for private PRs."
-          : response.status === 403 || response.status === 429
-            ? "GitHub's public API limit was reached. Try later or use the desktop app with gh signed in."
-            : `GitHub could not load this PR (${response.status}).`,
-      );
-    return response.json();
-  }
   const metadata = async (): Promise<PullFacts> => {
-    const pull = await read(endpoint);
+    const pull = await publicJson(endpoint, signal);
     return checked({
       repository,
       pr,
@@ -157,7 +141,10 @@ async function publicRead(repository: string, pr: number, signal: AbortSignal) {
   const first = await metadata();
   const paths: string[] = [];
   for (let page = 1; page <= Math.ceil(first.changedFiles / 100); page++) {
-    const files = await read(`${endpoint}/files?per_page=100&page=${page}`);
+    const files = await publicJson(
+      `${endpoint}/files?per_page=100&page=${page}`,
+      signal,
+    );
     if (!Array.isArray(files))
       throw new Error("GitHub returned an invalid file list.");
     paths.push(...files.map((file: { filename: string }) => file.filename));
@@ -181,3 +168,85 @@ export function createPullReader(gh?: GitHubCli): ReadPull {
     return publicRead(repository, pr, signal);
   };
 }
+
+async function publicJson(url: string, signal: AbortSignal) {
+  const response = await fetch(url, {
+    signal,
+    credentials: "omit",
+    cache: "no-store",
+    headers: { Accept: "application/vnd.github+json" },
+  });
+  if (!response.ok)
+    throw new Error(
+      response.status === 404
+        ? "This PR is private or unavailable. Use the desktop app with gh signed in for private PRs."
+        : response.status === 403 || response.status === 429
+          ? "GitHub's public API limit was reached. Try later or use the desktop app with gh signed in."
+          : `GitHub could not load this PR (${response.status}).`,
+    );
+  return response.json();
+}
+
+export type PullStatus = "Open" | "Draft" | "Closed" | "Merged";
+export type ReadPullStatus = (
+  repository: string,
+  pr: number,
+  signal: AbortSignal,
+) => Promise<PullStatus>;
+const STATUS_QUERY = `query($owner:String!,$name:String!,$pr:Int!){
+ repository(owner:$owner,name:$name){pullRequest(number:$pr){state isDraft}}
+}`;
+function status(state: unknown, draft: unknown): PullStatus {
+  if (
+    typeof state !== "string" ||
+    !["OPEN", "CLOSED", "MERGED"].includes(state) ||
+    typeof draft !== "boolean"
+  )
+    throw new Error("GitHub returned an unknown PR status.");
+  return state === "MERGED"
+    ? "Merged"
+    : state === "CLOSED"
+      ? "Closed"
+      : draft
+        ? "Draft"
+        : "Open";
+}
+
+/** One metadata read, without fetching routing labels or changed files. */
+export function createPullStatusReader(gh?: GitHubCli): ReadPullStatus {
+  return async (input, pr, signal) => {
+    const repository = repositoryName(input);
+    if (!Number.isSafeInteger(pr) || pr < 1)
+      throw new Error("Invalid PR number.");
+    signal.throwIfAborted();
+    if (gh) {
+      try {
+        const [owner, name] = repository.split("/");
+        const result = await gh<{
+          repository: {
+            pullRequest: { state: string; isDraft: boolean } | null;
+          } | null;
+        }>(STATUS_QUERY, { owner, name, pr }, signal);
+        const pull = result.repository?.pullRequest;
+        if (!pull)
+          throw new Error("This PR is unavailable to your GitHub account.");
+        return status(pull.state, pull.isDraft);
+      } catch (error) {
+        if (!(error instanceof GhUnavailable) || signal.aborted) throw error;
+      }
+    }
+    const pull = await publicJson(
+      `https://api.github.com/repos/${repository}/pulls/${pr}`,
+      signal,
+    );
+    if (
+      typeof pull.merged !== "boolean" ||
+      !["open", "closed"].includes(pull.state)
+    )
+      throw new Error("GitHub returned an unknown PR status.");
+    return status(
+      pull.merged ? "MERGED" : pull.state.toUpperCase(),
+      pull.draft,
+    );
+  };
+}
diff --git a/src/bundled/review-configuration/submissions.test.ts b/src/bundled/review-configuration/submissions.test.ts
index 75d7862ac3..af23f743ff 100644
--- a/src/bundled/review-configuration/submissions.test.ts
+++ b/src/bundled/review-configuration/submissions.test.ts
@@ -831,6 +831,7 @@ it("reminds saved reviewers without replacing threads or writing artifacts", asy
     channel,
     first,
     new AbortController().signal,
+    async () => "Open",
   );
   const replies = [...test.messages.values()].filter((event) =>
     event.tags.some((tag) => tag[0] === "e"),
@@ -859,6 +860,7 @@ it("reminds saved reviewers without replacing threads or writing artifacts", asy
       channel,
       first,
       new AbortController().signal,
+      async () => "Open",
     ),
   ).rejects.toThrow("Submission changed");
   expect(test.publish).toHaveBeenCalledTimes(4);
@@ -876,6 +878,7 @@ it("retries interrupted reminder batches without duplicating accepted replies",
       channel,
       first,
       new AbortController().signal,
+      async () => "Open",
     ),
   ).rejects.toThrow("offline");
   await remindSubmission(
@@ -883,6 +886,7 @@ it("retries interrupted reminder batches without duplicating accepted replies",
     channel,
     first,
     new AbortController().signal,
+    async () => "Open",
   );
   const replies = [...test.messages.values()].filter((event) =>
     event.tags.some((tag) => tag[0] === "e"),
@@ -907,7 +911,13 @@ it("refuses reminders for incomplete delivery and other submitters", async () =>
   const row = rows[0];
   if (!row) throw new Error("Missing fixture submission");
   await expect(
-    remindSubmission(test.session, channel, row, new AbortController().signal),
+    remindSubmission(
+      test.session,
+      channel,
+      row,
+      new AbortController().signal,
+      async () => "Open",
+    ),
   ).rejects.toThrow("Delivery is incomplete");
   await expect(
     remindSubmission(
@@ -915,7 +925,49 @@ it("refuses reminders for incomplete delivery and other submitters", async () =>
       channel,
       row,
       new AbortController().signal,
+      async () => "Open",
     ),
   ).rejects.toThrow("Only the original submitter");
   expect(test.publish).toHaveBeenCalledTimes(1);
 });
+
+it.each(["Closed", "Merged"] as const)(
+  "does not remind a PR that is now %s",
+  async (status) => {
+    const test = await fixture();
+    const row = await test.run();
+    const readStatus = vi.fn(async () => status);
+    await expect(
+      remindSubmission(
+        test.session,
+        channel,
+        row,
+        new AbortController().signal,
+        readStatus,
+      ),
+    ).rejects.toThrow("closed or merged");
+    expect(readStatus).toHaveBeenCalledWith(
+      "example-org/project",
+      123,
+      expect.any(AbortSignal),
+    );
+    expect(test.publish).toHaveBeenCalledTimes(2);
+  },
+);
+
+it("sends nothing when GitHub status cannot be confirmed", async () => {
+  const test = await fixture();
+  const row = await test.run();
+  await expect(
+    remindSubmission(
+      test.session,
+      channel,
+      row,
+      new AbortController().signal,
+      async () => {
+        throw new Error("GitHub unavailable");
+      },
+    ),
+  ).rejects.toThrow("GitHub unavailable");
+  expect(test.publish).toHaveBeenCalledTimes(2);
+});
diff --git a/src/bundled/review-configuration/submissions.ts b/src/bundled/review-configuration/submissions.ts
index 40b2ae9fbf..b8a489305d 100644
--- a/src/bundled/review-configuration/submissions.ts
+++ b/src/bundled/review-configuration/submissions.ts
@@ -1,3 +1,4 @@
+import type { ReadPullStatus } from "./pull-facts";
 import { laneMatches, type PullFacts } from "./routing";
 import { npubEncode } from "nostr-tools/nip19";
 import { profileMentionLink } from "../../features/messages/message-edit";
@@ -426,6 +427,7 @@ export async function remindSubmission(
   channel: string,
   previous: SavedSubmission,
   signal: AbortSignal,
+  readStatus: ReadPullStatus,
 ) {
   const read = session.snapshotRead;
   const outbox = session.outbox;
@@ -465,6 +467,16 @@ export async function remindSubmission(
         throw new Error(
           "Delivery is incomplete. Submit this PR again to finish delivery first.",
         );
+      const status = await readStatus(
+        current.value.config.repository,
+        current.value.pr,
+        signal,
+      );
+      signal.throwIfAborted();
+      if (status !== "Open" && status !== "Draft")
+        throw new Error(
+          "This PR is closed or merged. Reviewers were not reminded.",
+        );
       await notifyReviewers(session, channel, current, signal, true);
     },
   );

From 747edf3185ca33904cb84fc24328bb127f3dbbaa Mon Sep 17 00:00:00 2001
From: Ravneet Arora <rarora@squareup.com>
Date: Thu, 12 Nov 2026 18:06:58 -0500
Subject: [PATCH 15/17] Record PR review status from host-bound threads

Co-authored-by: maincourse <37ce551b493d4a998caf030929c47bce0b6a0e43f1178b3a63c4151d7c16b76e@buzz.block.builderlab.xyz>
Signed-off-by: Ravneet Arora <rarora@squareup.com>
---
 docs/buzz-help.md                             |   1 +
 docs/plugin-authoring-guide.md                |   9 +
 src/bundled/agents/AgentsPage.test.tsx        |   1 +
 src/bundled/codex/runtime.test.ts             |  43 +++-
 src/bundled/codex/runtime.ts                  |  10 +
 src/bundled/review-configuration/README.md    |  44 +++-
 .../ReviewConfigurationPage.tsx               |   7 +
 .../ReviewSubmissions.test.tsx                |  82 +++++++-
 .../ReviewSubmissions.tsx                     |  97 ++++++++-
 src/bundled/review-configuration/index.tsx    |   3 +-
 .../review-configuration.css                  |   6 +-
 .../review-configuration/submissions.test.ts  | 193 +++++++++++++++++-
 .../review-configuration/submissions.ts       | 170 +++++++++++++--
 src/buzz-mcp/client.ts                        |   3 +
 src/buzz-mcp/main.ts                          |  13 +-
 src/buzz-mcp/pr-review.ts                     | 111 ++++++++++
 src/buzz-mcp/session-tools.test.ts            |  22 ++
 src/buzz-mcp/session-tools.ts                 |  18 +-
 src/buzz-mcp/tools.ts                         |  10 +
 src/features/agent-harness/kit.test.ts        |  27 +++
 src/features/agent-harness/kit.ts             |  23 ++-
 src/features/agents/pr-review.ts              | 121 +++++++++++
 src/features/agents/service.test.ts           |   7 +
 src/features/agents/service.ts                |  12 +-
 24 files changed, 984 insertions(+), 49 deletions(-)
 create mode 100644 src/buzz-mcp/pr-review.ts
 create mode 100644 src/features/agents/pr-review.ts

diff --git a/docs/buzz-help.md b/docs/buzz-help.md
index 28ff6f50e0..dadc4062f2 100644
--- a/docs/buzz-help.md
+++ b/docs/buzz-help.md
@@ -1175,6 +1175,7 @@ confirmation. **Delete team** asks first; it doesn't delete the team's agents.
   Submitting an existing PR reuses its saved reviewers and threads and mentions
   them again in those threads. Incomplete initial delivery resumes from the original
   browser profile. An interrupted notification retries its saved messages.
+  Internal **Review status** is separate from GitHub status: Needs review, Waiting on author, or Done. Reviewers report through `pr_review_status_update` using only `done` or `wait_author`; Buzz supplies the review thread. The request includes instructions fetched from that tool. Remind and resubmitting an existing PR reset the lanes to Needs review. Reviews of a PR run sequentially in the same lane threads. Incoming reports update the table; Reload catches missed updates. Reporting requires native Codex thread sessions, a compatible shared harness, or a standalone MCP process bound to that thread by its host. An unsupported host refuses the update; a chat reply alone does not record a result.
   The separate Submit PR form has a **Back to Review Configuration** button. All pages remember the selected
   review channel. Reviewers must be owned by the signed-in identity and already
   belong to the channel. A connected agent runtime is needed for replies;
diff --git a/docs/plugin-authoring-guide.md b/docs/plugin-authoring-guide.md
index a3dc7c760c..8398ca3f5a 100644
--- a/docs/plugin-authoring-guide.md
+++ b/docs/plugin-authoring-guide.md
@@ -71,6 +71,15 @@ export function apply(ctx) {
 | `host` | Commands, HTTPS, processes, files | Requires `manifest.host` grants; see below. |
 | `pluginInstaller` (optional) | Ask the owner to install another plugin, check installation status, or access retained update reviews | `requestInstall(...)` resolves `"installed" \| "updated" \| "cancelled" \| "unavailable"` and never installs silently. Status methods are described below. `updates` is an optional, host-retained capability; see [Plugin architecture](plugin-architecture.md#plugin-installer). |
 
+Plugins can read the current documentation for a built-in or active plugin tool
+with `ctx.agents.describeTool(name)`. It returns a detached
+`{ name, description, inputSchema }`, or `undefined` when unavailable, and never
+returns the handler. Use this to compose agent instructions from the actual tool
+definition instead of maintaining a second copy. Read it when composing each
+message; already sent messages keep their original text. Feature-check the method
+on older hosts. Describing a tool does not grant access to call it or install it
+on another agent's runtime.
+
 The installation-status methods may be missing on older hosts even when `pluginInstaller` is available, so feature-check each method before calling it. `getInstallationStatus` returns `"installed"` when the manifest ID is in the ready catalog, `"absent"` when it is not, and `"unavailable"` while the catalog is not ready. Installed status is independent of whether the plugin is enabled, contributes UI, or came from a particular install source. A subscription reports later status changes; subscribe first, then read the current status to avoid missing a change between the read and subscription. Own the subscription with `ctx.effect`:
 
 ```js
diff --git a/src/bundled/agents/AgentsPage.test.tsx b/src/bundled/agents/AgentsPage.test.tsx
index b84d17928f..0f1f22e282 100644
--- a/src/bundled/agents/AgentsPage.test.tsx
+++ b/src/bundled/agents/AgentsPage.test.tsx
@@ -326,6 +326,7 @@ function setup(
     session: vi.fn(async () => {}),
     register: vi.fn(),
     addTool: vi.fn(),
+    describeTool: vi.fn(),
     tools: () => [],
     create: vi.fn(async () => {
       // `shown: false`: it was made for a community no longer selected.
diff --git a/src/bundled/codex/runtime.test.ts b/src/bundled/codex/runtime.test.ts
index c0bf57994c..7e89c2a64c 100644
--- a/src/bundled/codex/runtime.test.ts
+++ b/src/bundled/codex/runtime.test.ts
@@ -4858,7 +4858,7 @@ it("offers the tools plugins add, runs them as the agent here, and starts a new
   expect(JSON.stringify(reply?.result)).toContain("created");
   expect(call).toHaveBeenCalledWith(
     expect.objectContaining({ pubkey }),
-    { channel: "channel", root },
+    { channel: "channel", root, review: { channel: "channel", root } },
     { title: "Ship it" },
   );
   await f.complete();
@@ -7332,3 +7332,44 @@ it("neither lists nor runs the retired owner-read tools, while its own reads wor
   );
   await f.complete();
 });
+
+it("supplies an immutable review thread outside tool arguments and omits it for channel-wide sessions", async () => {
+  const f = fixture();
+  const contexts: unknown[] = [];
+  f.added.push({
+    name: "inspect_review_context",
+    description: "Inspect host context.",
+    inputSchema: { type: "object", properties: {} },
+    call: async (_client, context) => {
+      contexts.push(context.review);
+      return "inspected";
+    },
+  });
+  await f.runtime.run(f.delivery("review"));
+  await vi.waitFor(() => expect(f.starts()).toHaveLength(1));
+  await f.tool("inspect_review_context", {
+    review: { channel: "wrong", root: "wrong" },
+  });
+  await f.runtime.run(f.delivery("follow-up"));
+  await vi.waitFor(() =>
+    expect(f.sent.some((wire) => wire.method === "turn/steer")).toBe(true),
+  );
+  await f.tool("inspect_review_context", {});
+  expect(contexts).toEqual([
+    { channel: "channel", root },
+    { channel: "channel", root },
+  ]);
+  await f.complete();
+  await vi.waitFor(() =>
+    expect(f.runtime.sessions(pubkey)[0]?.status).toBe("Idle"),
+  );
+  const next = f.delivery("channel scope", "d".repeat(64));
+  await f.runtime.run({
+    ...next,
+    config: { ...(next.config as object), scope: "channel" },
+  });
+  await vi.waitFor(() => expect(f.starts()).toHaveLength(2));
+  await f.tool("inspect_review_context", {}, 1);
+  expect(contexts[2]).toBeUndefined();
+  await f.complete(1);
+});
diff --git a/src/bundled/codex/runtime.ts b/src/bundled/codex/runtime.ts
index eb548fe797..5933cfee38 100644
--- a/src/bundled/codex/runtime.ts
+++ b/src/bundled/codex/runtime.ts
@@ -147,6 +147,7 @@ type Saved = {
   protection?: string;
 };
 type Active = {
+  readonly review?: Context["review"];
   /** The server this turn runs on; steering must reach the same process. */
   rpc: AppServer;
   threadId?: string;
@@ -2250,6 +2251,7 @@ export class CodexRuntime {
     // A watch or timer turn has no default destination.
     const context: Context = request
       ? {
+          ...(active?.review ? { review: active.review } : {}),
           channel: request.conversation.channelId,
           ...(request.toolRoot ? { root: request.toolRoot } : {}),
           ...(request.toolRoot && !request.conversation.root
@@ -2699,6 +2701,14 @@ export class CodexRuntime {
       ...(adopted && lane.voice ? [lane.voice.signal] : []),
     ]);
     const active: Active = {
+      ...(request.conversation.root && !request.wake
+        ? {
+            review: {
+              channel: request.conversation.channelId,
+              root: request.conversation.root,
+            },
+          }
+        : {}),
       rpc: server.rpc,
       ...(adopted && lane.voice
         ? { threadId: lane.voice.loaded.threadId, turnId: adopted }
diff --git a/src/bundled/review-configuration/README.md b/src/bundled/review-configuration/README.md
index ea8e6bef55..d066083e94 100644
--- a/src/bundled/review-configuration/README.md
+++ b/src/bundled/review-configuration/README.md
@@ -17,7 +17,7 @@ The separate **Pull requests** page shows previous submissions in a bordered tab
 
 Submitting an already-delivered PR sends a reviewer mention in each saved lane
 thread. It preserves the saved reviewers and instructions and creates no new
-threads or review rounds. Incomplete original submissions resume delivery from
+threads. It resets each lane to Needs review. Incomplete original submissions resume delivery from
 the original browser profile instead. These actions run only on Submit; opening
 the page or a thread never dispatches messages.
 
@@ -132,8 +132,7 @@ A failed notification leaves existing thread buttons available and reports failu
 Opening Submit PR reads the latest 100 submissions once, with truncation/error
 feedback. Submit reads configurations and the current submission, then verifies
 reviewer profiles and ownership before dispatch. No polling or reconnect reads
-are added. No GitHub comments, verdict synchronization, scheduled reminders, or
-agent runtime are added.
+are added. No GitHub comments or scheduled reminders are added.
 
 Try a fresh test PR URL → Submit PR → Open a lane thread. Check its URL, reviewer
 mention, and complete instructions. Submit the same URL again: the same threads
@@ -157,3 +156,42 @@ public API without credentials, so private PRs and rate-limited requests need th
 desktop host. The reader rejects incomplete/changing metadata and supports at
 most 3,000 changed files and 100 labels; it never routes on a truncated file list.
 Metadata is fetched during new submission only; there is no poller.
+
+
+## Internal review status (POC)
+
+Each lane starts at **Needs review**. Its assigned reviewer calls the standard
+Buzz tool `pr_review_status_update` with only `status: "done"` or
+`status: "wait_author"`. The host supplies the review thread outside the model's
+arguments; the tool resolves its current assignment and checks the reviewer.
+One review is active per PR; re-reviews happen sequentially in the saved lane
+threads. This POC does not bind a late call from an older turn to an older round.
+
+**Remind** and resubmitting a listed PR reset its lanes to **Needs review** and
+send updated requests in those same threads. Failed notification batches resume
+from the original browser profile without replacing accepted messages. Older
+submissions gain status reporting when reminded. Overall status is **Waiting on
+author** if any lane needs changes, **Needs review** if any lane is pending, and
+**Done** when all lanes are done. GitHub status remains separate.
+
+Signed kind-9 status messages are both the durable report and the thread
+notification. The tool and dashboard validate the assigned reviewer and current
+request token. These are application checks; the generic relay enforces its
+existing signature and channel-access rules. Report retries reuse the saved
+status; sequential updates use a sequence number for ordering within a second.
+The table applies incoming reports without polling. Reload reconciles shared
+submission changes and missed reports. A full snapshot uses one artifact read
+and up to twelve report reads, in batches of 100 current request tokens; capped
+report pages fail visibly rather than supplying incomplete statuses.
+
+The plugin obtains the tool's description and schema with
+`agents.describeTool("pr_review_status_update")` when composing a request and
+appends them after lane instructions. It maintains no copy of that documentation.
+
+Native Codex thread sessions and the shared HarnessKit provide review context.
+A standalone MCP host can set `BUZZ_CHANNEL` and `BUZZ_REVIEW_THREAD` when starting
+a process dedicated to that thread. Never reuse that process across threads.
+Channel-wide sessions, external MCP, and adapters without this host wiring refuse
+status updates. Merely including a thread ID in the prompt does not enable it.
+The existing standalone ACP lab launcher still needs that environment wiring;
+this feature does not add it to every adapter automatically.
diff --git a/src/bundled/review-configuration/ReviewConfigurationPage.tsx b/src/bundled/review-configuration/ReviewConfigurationPage.tsx
index ee07c50a3b..4e84f7ddde 100644
--- a/src/bundled/review-configuration/ReviewConfigurationPage.tsx
+++ b/src/bundled/review-configuration/ReviewConfigurationPage.tsx
@@ -1,3 +1,4 @@
+import type { ToolDescription } from "../../buzz-mcp/session-tools";
 import {
   createPullReader,
   createPullStatusReader,
@@ -80,6 +81,7 @@ export function ReviewConfigurationPage({
   navigator,
   readPull = publicPullReader,
   readStatus = publicStatusReader,
+  describeTool,
   page = "configuration",
 }: {
   page?: ReviewPage;
@@ -87,6 +89,7 @@ export function ReviewConfigurationPage({
   navigator?: Navigation;
   readPull?: ReadPull;
   readStatus?: ReadPullStatus;
+  describeTool?: ((name: string) => ToolDescription | undefined) | undefined;
 }) {
   const connection = useRelayConnection(relay);
   if (connection.status === "ready")
@@ -97,6 +100,7 @@ export function ReviewConfigurationPage({
         page={page}
         readPull={readPull}
         readStatus={readStatus}
+        describeTool={describeTool}
         onNavigate={
           navigator
             ? async (page) => {
@@ -153,12 +157,14 @@ export function ReviewConfigurationCommunity({
   onNavigate,
   readPull = publicPullReader,
   readStatus = publicStatusReader,
+  describeTool,
   page = "configuration",
 }: {
   session: RelaySession;
   page?: ReviewPage;
   readPull?: ReadPull;
   readStatus?: ReadPullStatus;
+  describeTool?: ((name: string) => ToolDescription | undefined) | undefined;
   onNavigate?: ((page: ReviewPage) => Promise<void>) | undefined;
   onOpenThread?: ((channel: string, id: string) => Promise<void>) | undefined;
 }) {
@@ -278,6 +284,7 @@ export function ReviewConfigurationCommunity({
             onOpenThread={onOpenThread}
             readPull={readPull}
             readStatus={readStatus}
+            describeTool={describeTool}
           />
         ) : (
           <ChannelConfiguration
diff --git a/src/bundled/review-configuration/ReviewSubmissions.test.tsx b/src/bundled/review-configuration/ReviewSubmissions.test.tsx
index 88924211ca..2ab1da849c 100644
--- a/src/bundled/review-configuration/ReviewSubmissions.test.tsx
+++ b/src/bundled/review-configuration/ReviewSubmissions.test.tsx
@@ -1,3 +1,5 @@
+import type { LiveListener } from "../../features/relay/incoming";
+import { describeTool } from "../../buzz-mcp/session-tools";
 // @vitest-environment jsdom
 import {
   act,
@@ -92,7 +94,14 @@ function fixture(
     pending: false,
     archives: { status: "ready" },
   };
+  let live: LiveListener | undefined;
   const session = {
+    subscribeLive: (listener: LiveListener) => {
+      live = listener;
+      return () => {
+        live = undefined;
+      };
+    },
     viewer,
     agentChoices: {
       subscribe: () => () => {},
@@ -123,10 +132,13 @@ function fixture(
       onOpenThread={onOpenThread}
       readPull={readPull}
       readStatus={readStatus}
+      describeTool={describeTool}
     />,
   );
   return {
     ...view,
+    emit: (events: Parameters<LiveListener>[0]["events"]) =>
+      act(() => live?.({ events })),
     session,
     readPull,
     readStatus,
@@ -289,7 +301,7 @@ it("shows all PRs in a table without submission controls, and deletion requires
   expect(deleteSubmission).toHaveBeenCalledWith(
     test.session,
     "channel",
-    record,
+    expect.objectContaining(record),
     expect.any(AbortSignal),
   );
   expect(submitReview).not.toHaveBeenCalled();
@@ -378,6 +390,7 @@ it("reminds from a row, guards duplicate clicks and reports success or failure",
     await new Promise<void>((resolve) => {
       finish = resolve;
     });
+    return record;
   });
   const test = fixture("all");
   const button = await screen.findByRole("button", {
@@ -397,9 +410,10 @@ it("reminds from a row, guards duplicate clicks and reports success or failure",
   expect(remindSubmission).toHaveBeenCalledWith(
     test.session,
     "channel",
-    record,
+    expect.objectContaining(record),
     expect.any(AbortSignal),
     expect.any(Function),
+    expect.stringContaining("pr_review_status_update"),
   );
   expect(submitReview).not.toHaveBeenCalled();
   vi.mocked(remindSubmission).mockRejectedValueOnce(
@@ -422,6 +436,7 @@ it("aborts pending reminders when leaving the page", async () => {
       await new Promise<void>((resolve) => {
         finish = resolve;
       });
+      return record;
     },
   );
   const test = fixture("all");
@@ -505,3 +520,66 @@ it("limits status reads and aborts queued work when leaving the list", async ()
   });
   expect(readStatus).toHaveBeenCalledTimes(4);
 });
+
+it("recovers a report received while a reminder is still sending", async () => {
+  const request = "11111111-1111-4111-8111-111111111111";
+  const next: SavedSubmission = {
+    ...record,
+    revision: "f".repeat(64),
+    value: {
+      ...record.value,
+      threads: [{ ...record.value.threads[0], request }],
+    },
+  };
+  const report = {
+    id: "1".repeat(64),
+    kind: 9,
+    created_at: 100,
+    pubkey: "a".repeat(64),
+    content: "Review status: Done.",
+    tags: [
+      ["h", "channel"],
+      ["t", "buzz.review.status"],
+      ["r", request],
+      ["review", record.artifactId, "0"],
+      ["e", "e".repeat(64), "", "reply"],
+      ["status", "done"],
+      ["review-sequence", "1"],
+    ],
+  } as import("../../features/relay/events").RelayEvent;
+  vi.mocked(loadSubmissions)
+    .mockResolvedValueOnce({ rows: [record], warning: "" })
+    .mockResolvedValue({
+      rows: [{ ...next, reviewReports: [report], reviewStates: ["done"] }],
+      warning: "",
+    });
+  let finish: ((value: SavedSubmission) => void) | undefined;
+  vi.mocked(remindSubmission).mockImplementationOnce(
+    () =>
+      new Promise((resolve) => {
+        finish = resolve;
+      }),
+  );
+  const test = fixture("all");
+  const row = (
+    await screen.findByRole("link", { name: "example-org/project#42" })
+  ).closest("tr");
+  if (!row) throw new Error("Missing PR row");
+  await waitFor(() => expect(test.readStatus).toHaveBeenCalledOnce());
+  await test.user.click(
+    within(row).getByRole("button", {
+      name: "Remind reviewers for example-org/project#42",
+    }),
+  );
+  test.emit([report]);
+  await act(async () => finish?.(next));
+  await waitFor(() =>
+    expect(
+      within(row).getAllByText("Done", { exact: true }).length,
+    ).toBeGreaterThan(0),
+  );
+  expect(loadSubmissions).toHaveBeenCalledTimes(2);
+  const reads = vi.mocked(test.readStatus).mock.calls.length;
+  test.emit([report]);
+  expect(vi.mocked(test.readStatus).mock.calls.length).toBe(reads);
+});
diff --git a/src/bundled/review-configuration/ReviewSubmissions.tsx b/src/bundled/review-configuration/ReviewSubmissions.tsx
index c874de32b7..2094625ae2 100644
--- a/src/bundled/review-configuration/ReviewSubmissions.tsx
+++ b/src/bundled/review-configuration/ReviewSubmissions.tsx
@@ -1,3 +1,15 @@
+import type { EventData } from "../../features/relay/events";
+import type { ToolDescription } from "../../buzz-mcp/session-tools";
+import {
+  overallReviewStatus,
+  REVIEW_REPORT,
+  type ReviewState,
+} from "../../features/agents/pr-review";
+const reviewLabels: Record<ReviewState, string> = {
+  need_review: "Needs review",
+  done: "Done",
+  wait_author: "Waiting on author",
+};
 import { useEffect, useRef, useState } from "react";
 import { useAgentChoices } from "../../features/agents/use-choices";
 import type { RelaySession } from "../../features/relay/session";
@@ -20,6 +32,7 @@ import {
 } from "./pull-facts";
 import {
   loadSubmissions,
+  applyReviewReports,
   deleteSubmission,
   remindSubmission,
   prUrl,
@@ -42,6 +55,7 @@ export function ReviewSubmissions({
   onOpenThread,
   readPull = publicPullReader,
   readStatus = publicStatusReader,
+  describeTool,
 }: {
   session: RelaySession;
   mode?: "submit" | "all";
@@ -51,6 +65,7 @@ export function ReviewSubmissions({
   onOpenThread?: ((channel: string, id: string) => Promise<void>) | undefined;
   readPull?: ReadPull;
   readStatus?: ReadPullStatus;
+  describeTool?: ((name: string) => ToolDescription | undefined) | undefined;
 }) {
   const choices = useAgentChoices(session, true, true);
   const [pr, setPr] = useState("");
@@ -83,6 +98,23 @@ export function ReviewSubmissions({
     const controller = new AbortController();
     setListError("");
     setListLoading(true);
+    // Subscribe before reading so reports arriving during the snapshot are kept.
+    const pending: EventData[] = [];
+    let loaded = false;
+    const stop = session.subscribeLive?.(({ events }) => {
+      const reports = events.filter(
+        (event) =>
+          event.kind === 9 &&
+          event.tags.some((tag) => tag[0] === "h" && tag[1] === channel) &&
+          event.tags.some((tag) => tag[0] === "t" && tag[1] === REVIEW_REPORT),
+      );
+      if (!reports.length) return;
+      if (!loaded) pending.push(...reports);
+      else
+        setRows((rows) =>
+          rows.map((row) => applyReviewReports(row, channel, reports)),
+        );
+    });
     loadSubmissions(
       session,
       channel,
@@ -90,10 +122,16 @@ export function ReviewSubmissions({
     )
       .then((next) => {
         if (controller.signal.aborted) return;
-        setRows(next.rows);
+        loaded = true;
+        setRows(
+          next.rows.map((row) => applyReviewReports(row, channel, pending)),
+        );
+        pending.length = 0;
         setWarning(next.warning);
       })
       .catch((reason: unknown) => {
+        loaded = true;
+        pending.length = 0;
         if (!controller.signal.aborted)
           setListError(
             reason instanceof Error
@@ -104,9 +142,14 @@ export function ReviewSubmissions({
       .finally(() => {
         if (!controller.signal.aborted) setListLoading(false);
       });
-    return () => controller.abort();
+    return () => {
+      controller.abort();
+      stop?.();
+    };
   }, [session, channel, reload, mode]);
 
+  const statusRowsKey = rows.map((row) => row.revision).join(":");
+  // biome-ignore lint/correctness/useExhaustiveDependencies: Report updates preserve PR/revision; only saved-row changes and explicit Reload require GitHub reads.
   useEffect(() => {
     if (mode !== "all") return;
     const controller = new AbortController();
@@ -146,7 +189,7 @@ export function ReviewSubmissions({
     for (let index = 0; index < Math.min(rows.length, 4); index++)
       void worker();
     return () => controller.abort();
-  }, [rows, mode, readStatus]);
+  }, [statusRowsKey, mode, readStatus, reload]);
 
   async function submit() {
     if (operation.current || !writable) return;
@@ -198,6 +241,7 @@ export function ReviewSubmissions({
         () => {
           existing = true;
         },
+        toolDocumentation(),
       );
       if (controller.signal.aborted) return;
       setResult(record);
@@ -219,6 +263,15 @@ export function ReviewSubmissions({
     }
   }
 
+  function toolDocumentation() {
+    const tool = describeTool?.("pr_review_status_update");
+    if (!tool)
+      throw new Error(
+        "Review reporting is unavailable. Update Buzz before sending review requests.",
+      );
+    return `Tool: ${tool.name}\n${tool.description}\nArguments: ${JSON.stringify(tool.inputSchema)}`;
+  }
+
   async function remind(row: SavedSubmission) {
     if (operation.current || !writable) return;
     const controller = new AbortController();
@@ -228,7 +281,7 @@ export function ReviewSubmissions({
     const name = `${row.value.config.repository}#${row.value.pr}`;
     setStatus(`Reminding reviewers for ${name}…`);
     try {
-      await remindSubmission(
+      const updated = await remindSubmission(
         session,
         channel,
         row,
@@ -251,9 +304,22 @@ export function ReviewSubmissions({
             throw reason;
           }
         },
+        toolDocumentation(),
       );
-      if (!controller.signal.aborted)
-        setStatus(`Reviewers reminded for ${name} in their existing threads.`);
+      if (!controller.signal.aborted) {
+        // A reviewer may have reported while later lane notifications were pending.
+        // Reload captures those reports; the read effect buffers concurrent arrivals.
+        setReload((value) => value + 1);
+        if (updated)
+          setRows((rows) =>
+            rows.map((entry) =>
+              entry.artifactId === updated.artifactId ? updated : entry,
+            ),
+          );
+        setStatus(
+          `Reviewers reminded for ${name} in their existing threads. Status reset to needs review.`,
+        );
+      }
     } catch (reason) {
       if (!controller.signal.aborted) {
         setStatus("");
@@ -323,6 +389,11 @@ export function ReviewSubmissions({
                   />
                 ))}
               </div>
+              {lane && (
+                <span>
+                  {reviewLabels[row.reviewStates?.[index] ?? "need_review"]}
+                </span>
+              )}
               {thread.id ? (
                 <Button
                   size="sm"
@@ -364,6 +435,7 @@ export function ReviewSubmissions({
             <tr>
               <th scope="col">Pull request</th>
               {deletable && <th scope="col">Status</th>}
+              <th scope="col">Review status</th>
               <th scope="col">Delivery</th>
               <th scope="col">Reviewers &amp; threads</th>
               {deletable && <th scope="col">Actions</th>}
@@ -382,6 +454,19 @@ export function ReviewSubmissions({
                     {statuses[row.revision]?.value ?? "Loading…"}
                   </td>
                 )}
+                <td>
+                  {
+                    reviewLabels[
+                      overallReviewStatus(
+                        row.value.threads.flatMap((_thread, index) =>
+                          submissionLane(row.value, index)
+                            ? [row.reviewStates?.[index] ?? "need_review"]
+                            : [],
+                        ),
+                      )
+                    ]
+                  }
+                </td>
                 <td>
                   {row.value.threads.every((thread) => thread.delivered)
                     ? "Requests delivered"
diff --git a/src/bundled/review-configuration/index.tsx b/src/bundled/review-configuration/index.tsx
index 631c0459ea..c1e4000f4c 100644
--- a/src/bundled/review-configuration/index.tsx
+++ b/src/bundled/review-configuration/index.tsx
@@ -7,7 +7,7 @@ import {
   type ReviewPage,
 } from "./ReviewConfigurationPage";
 
-export const inject = ["pages", "relay", "navigation", "host"];
+export const inject = ["pages", "relay", "navigation", "host", "agents"];
 export const apply: PluginModule["apply"] = (ctx) => {
   const { relay, navigation: navigator } = ctx;
   const gh = gitHubCli(ctx.host);
@@ -27,6 +27,7 @@ export const apply: PluginModule["apply"] = (ctx) => {
           navigator={navigator}
           readPull={readPull}
           readStatus={readStatus}
+          describeTool={(name) => ctx.agents.describeTool(name)}
         />
       ),
     });
diff --git a/src/bundled/review-configuration/review-configuration.css b/src/bundled/review-configuration/review-configuration.css
index ed43ff95e6..35f9100648 100644
--- a/src/bundled/review-configuration/review-configuration.css
+++ b/src/bundled/review-configuration/review-configuration.css
@@ -115,7 +115,7 @@
 }
 .review-config-table {
   width: 100%;
-  min-width: 44rem;
+  min-width: 56rem;
   border-collapse: collapse;
   background: var(--surface-panel);
 }
@@ -124,6 +124,10 @@
   text-align: left;
   vertical-align: top;
   padding: var(--space-3);
+  overflow-wrap: normal;
+}
+.review-config-table th:first-child {
+  min-width: 12rem;
   overflow-wrap: anywhere;
 }
 .review-config-table thead {
diff --git a/src/bundled/review-configuration/submissions.test.ts b/src/bundled/review-configuration/submissions.test.ts
index af23f743ff..8c0e54dde6 100644
--- a/src/bundled/review-configuration/submissions.test.ts
+++ b/src/bundled/review-configuration/submissions.test.ts
@@ -166,6 +166,7 @@ async function fixture() {
   return {
     owner,
     agent,
+    profile,
     heads,
     messages,
     session,
@@ -230,7 +231,11 @@ it("saves the instruction snapshot and creates only distinct lane threads, witho
   expect(
     (await loadSubmissions(f.session, channel, new AbortController().signal))
       .rows[0],
-  ).toEqual(record);
+  ).toEqual({
+    ...record,
+    reviewStates: ["need_review", "need_review"],
+    reviewReports: [],
+  });
   await f.run();
   expect(f.publish).toHaveBeenCalledTimes(2);
 });
@@ -364,7 +369,7 @@ it("can resume after a proven rejection before enqueue", async () => {
   const saved = (
     await loadSubmissions(f.session, channel, new AbortController().signal)
   ).rows[0];
-  expect(saved?.value.threads[0]).toEqual({});
+  expect(saved?.value.threads[0]).toEqual({ request: expect.any(String) });
   await f.run("123", undefined, true);
   expect(f.messages.size).toBe(2);
 });
@@ -495,7 +500,7 @@ it("infers a canonical repository only from a valid full PR URL", () => {
     expect(() => pullRepository(input)).toThrow();
 });
 
-it("explicit resubmission notifies saved reviewers in existing threads without new artifacts or GitHub reads", async () => {
+it("explicit resubmission resets review requests in existing threads without GitHub reads", async () => {
   const test = await fixture();
   const first = await test.run();
   const writes = test.artifactPublish.mock.calls.length;
@@ -517,8 +522,13 @@ it("explicit resubmission notifies saved reviewers in existing threads without n
       existing,
     );
   const result = await again();
-  expect(result.value.threads).toEqual(first.value.threads);
-  expect(test.artifactPublish).toHaveBeenCalledTimes(writes);
+  expect(result.value.threads.map((thread) => thread.id)).toEqual(
+    first.value.threads.map((thread) => thread.id),
+  );
+  expect(result.value.threads[0]?.request).not.toBe(
+    first.value.threads[0]?.request,
+  );
+  expect(test.artifactPublish).toHaveBeenCalledTimes(writes + 2);
   expect(facts).not.toHaveBeenCalled();
   expect(existing).toHaveBeenCalledOnce();
   const replies = [...test.messages.values()].filter((event) =>
@@ -644,7 +654,9 @@ it("retries a partially delivered notification batch with the same message ident
       event.tags.some((tag) => tag[0] === "subject"),
     ),
   ).toHaveLength(2);
-  expect((await test.run()).value.threads).toEqual(first.value.threads);
+  expect((await test.run()).value.threads.map((thread) => thread.id)).toEqual(
+    first.value.threads.map((thread) => thread.id),
+  );
 });
 
 it("deletes from the shared list and starts fresh threads using current routing after reload", async () => {
@@ -822,11 +834,11 @@ it("refuses a foreign submitter replacing a deleted record", async () => {
   expect(f.messages.size).toBe(2);
 });
 
-it("reminds saved reviewers without replacing threads or writing artifacts", async () => {
+it("reminds saved reviewers and resets requests without replacing threads", async () => {
   const test = await fixture();
   const first = await test.run();
   const writes = test.artifactPublish.mock.calls.length;
-  await remindSubmission(
+  const updated = await remindSubmission(
     test.session,
     channel,
     first,
@@ -847,11 +859,11 @@ it("reminds saved reviewers without replacing threads or writing artifacts", asy
     expect(reply.tags).toContainEqual(["p", test.agent.pubkey]);
     expect(reply.content).toContain("Review reminder.");
   }
-  expect(test.artifactPublish).toHaveBeenCalledTimes(writes);
+  expect(test.artifactPublish).toHaveBeenCalledTimes(writes + 2);
   await deleteSubmission(
     test.session,
     channel,
-    first,
+    updated,
     new AbortController().signal,
   );
   await expect(
@@ -881,10 +893,14 @@ it("retries interrupted reminder batches without duplicating accepted replies",
       async () => "Open",
     ),
   ).rejects.toThrow("offline");
+  const reloaded = (
+    await loadSubmissions(test.session, channel, new AbortController().signal)
+  ).rows[0];
+  if (!reloaded) throw new Error("Missing reloaded submission");
   await remindSubmission(
     test.session,
     channel,
-    first,
+    reloaded,
     new AbortController().signal,
     async () => "Open",
   );
@@ -971,3 +987,158 @@ it("sends nothing when GitHub status cannot be confirmed", async () => {
   ).rejects.toThrow("GitHub unavailable");
   expect(test.publish).toHaveBeenCalledTimes(2);
 });
+
+it("completes the status-only review loop, resets on Remind, and ignores other reviewers", async () => {
+  const { callTool, TOOLS } = await import("../../buzz-mcp/tools");
+  const test = await fixture();
+  const first = await test.run();
+  const roots = first.value.threads.map((thread) => thread.id ?? "");
+  const snapshotRead = test.session.snapshotRead;
+  if (!snapshotRead) throw new Error("Missing reader");
+  const schema = TOOLS.find(
+    (tool) => tool.name === "pr_review_status_update",
+  )?.inputSchema;
+  expect(schema).toMatchObject({
+    additionalProperties: false,
+    required: ["status"],
+    properties: { status: { enum: ["done", "wait_author"] } },
+  });
+  expect(Object.keys(schema?.properties ?? {})).toEqual(["status"]);
+  const query = vi.fn(
+    async (filters: readonly import("../../buzz-mcp/client").Filter[]) => {
+      const filter = filters[0];
+      if (!filter) throw new Error("Missing filter");
+      const source = filter.artifact
+        ? [...test.heads.values()]
+        : [...test.messages.values()];
+      return source.filter((event) =>
+        Object.entries(filter).every(([key, value]) => {
+          if (key === "kinds") return (value as number[]).includes(event.kind);
+          if (key === "authors")
+            return (value as string[]).includes(event.pubkey);
+          if (key.startsWith("#"))
+            return event.tags.some(
+              (tag) =>
+                tag[0] === key.slice(1) &&
+                (value as string[]).includes(tag[1] ?? ""),
+            );
+          return true;
+        }),
+      );
+    },
+  );
+  const publish = vi.fn(
+    async (template: import("../../buzz-mcp/client").Template) => {
+      const event = signed(test.agent, {
+        ...template,
+        tags: template.tags.map((tag) => [...tag]),
+      });
+      test.messages.set(event.id, event);
+      return event;
+    },
+  );
+  const client = {
+    pubkey: test.agent.pubkey,
+    key: test.agent.pubkey,
+    query,
+    publish,
+  } as unknown as import("../../buzz-mcp/client").BuzzClient;
+  const report = (index: number, status: string, extra = {}) =>
+    callTool(
+      client,
+      {
+        review: { channel, root: roots[index] ?? "" },
+      },
+      "pr_review_status_update",
+      { status, ...extra },
+    );
+  // The dashboard reads the exact signed events published through the tool.
+  vi.mocked(snapshotRead).mockImplementation(
+    async (filters) =>
+      query(filters) as Promise<
+        import("../../features/relay/events").RelayEvent[]
+      >,
+  );
+  await expect(report(0, "waiting")).rejects.toThrow("Only status");
+  await expect(report(0, "done", { pr: 999 })).rejects.toThrow("Only status");
+  await expect(
+    callTool(client, {}, "pr_review_status_update", { status: "done" }),
+  ).rejects.toThrow("host has not supplied");
+  await expect(
+    callTool(
+      { ...client, pubkey: "f".repeat(64) },
+      { review: { channel, root: roots[0] ?? "" } },
+      "pr_review_status_update",
+      { status: "done" },
+    ),
+  ).rejects.toThrow("no unique active review");
+  expect(publish).not.toHaveBeenCalled();
+  await report(0, "wait_author");
+  await report(1, "done");
+  const read = () =>
+    loadSubmissions(test.session, channel, new AbortController().signal);
+  expect((await read()).rows[0]?.reviewStates).toEqual(["wait_author", "done"]);
+  await report(0, "wait_author");
+  expect(publish).toHaveBeenCalledTimes(2);
+  await report(0, "done");
+  expect((await read()).rows[0]?.reviewStates).toEqual(["done", "done"]);
+  vi.mocked(snapshotRead).mockImplementation(async (filters) =>
+    filters[0]?.kinds?.includes(0)
+      ? [test.profile]
+      : (query(filters) as Promise<
+          import("../../features/relay/events").RelayEvent[]
+        >),
+  );
+  const reset = await remindSubmission(
+    test.session,
+    channel,
+    first,
+    new AbortController().signal,
+    async () => "Open",
+    "Tool-owned instructions",
+  );
+  expect(reset.value.threads.map((thread) => thread.id)).toEqual(
+    first.value.threads.map((thread) => thread.id),
+  );
+  expect((await read()).rows[0]?.reviewStates).toEqual([
+    "need_review",
+    "need_review",
+  ]);
+  await report(0, "done");
+  expect((await read()).rows[0]?.reviewStates).toEqual(["done", "need_review"]);
+  const reminder = [...test.messages.values()].find((event) =>
+    event.content.includes("Review reminder."),
+  );
+  expect(reminder?.content).toContain("Tool-owned instructions");
+  await deleteSubmission(
+    test.session,
+    channel,
+    reset,
+    new AbortController().signal,
+  );
+  await expect(report(0, "done")).rejects.toThrow("no unique active review");
+});
+
+it("refuses a capped report snapshot instead of showing missing reports as needs review", async () => {
+  const test = await fixture();
+  await test.run();
+  const read = vi.mocked(
+    test.session.snapshotRead as NonNullable<RelaySession["snapshotRead"]>,
+  );
+  const original = read.getMockImplementation();
+  if (!original) throw new Error("Missing fixture reader");
+  read.mockImplementation(async (filters, options) =>
+    filters[0]?.["#t"]
+      ? Array.from({ length: 500 }, () =>
+          signed(test.agent, {
+            kind: 9,
+            content: "report",
+            tags: [["h", channel]],
+          }),
+        )
+      : original(filters, options),
+  );
+  await expect(
+    loadSubmissions(test.session, channel, new AbortController().signal),
+  ).rejects.toThrow("read reached its limit");
+});
diff --git a/src/bundled/review-configuration/submissions.ts b/src/bundled/review-configuration/submissions.ts
index b8a489305d..41e7e7e5e5 100644
--- a/src/bundled/review-configuration/submissions.ts
+++ b/src/bundled/review-configuration/submissions.ts
@@ -1,3 +1,11 @@
+import {
+  REVIEW_REPORT,
+  REVIEW_SUBMISSION,
+  latestReport,
+  reportStatus,
+  reviewToken,
+  type ReviewState,
+} from "../../features/agents/pr-review";
 import type { ReadPullStatus } from "./pull-facts";
 import { laneMatches, type PullFacts } from "./routing";
 import { npubEncode } from "nostr-tools/nip19";
@@ -17,10 +25,15 @@ import {
   type SavedReviewConfig,
 } from "./configuration";
 
-const TYPE = "buzz.review.submission";
+const TYPE = REVIEW_SUBMISSION;
 const HEX = /^[0-9a-f]{64}$/;
 const UUID = /^[0-9a-f-]{36}$/;
-type Thread = { id?: string; started?: true; delivered?: true };
+type Thread = {
+  id?: string;
+  started?: true;
+  delivered?: true;
+  request?: string;
+};
 export type Submission = {
   version: 1 | 2 | 3;
   generation?: string;
@@ -31,11 +44,14 @@ export type Submission = {
   device: string;
   threads: Thread[];
   deleted?: true;
+  notifying?: true;
 };
 export type SavedSubmission = {
   value: Submission;
   artifactId: string;
   revision: string;
+  reviewStates?: ReviewState[];
+  reviewReports?: EventData[];
 };
 const tag = (event: EventData, name: string) =>
   event.tags.find((t) => t[0] === name)?.[1];
@@ -99,6 +115,7 @@ async function decode(
     !HEX.test(value.configRevision) ||
     !UUID.test(value.device) ||
     (value.deleted !== undefined && value.deleted !== true) ||
+    (value.notifying !== undefined && value.notifying !== true) ||
     config.lanes.some((lane) => lane.reviewers.length !== 1) ||
     !Array.isArray(value.threads) ||
     value.threads.length !==
@@ -107,6 +124,9 @@ async function decode(
       (thread) =>
         !thread ||
         (thread.started !== undefined && thread.started !== true) ||
+        (thread.request !== undefined &&
+          (typeof thread.request !== "string" ||
+            !reviewToken.test(thread.request))) ||
         (thread.id !== undefined && !HEX.test(thread.id)) ||
         (thread.delivered !== undefined &&
           (thread.delivered !== true || !thread.id)),
@@ -141,12 +161,40 @@ export async function loadSubmissions(
   const results = await Promise.allSettled(
     events.slice(0, 100).map((event) => decode(event, channel)),
   );
-  return {
-    rows: results.flatMap((result) =>
-      result.status === "fulfilled" && !result.value.value.deleted
-        ? [result.value]
-        : [],
+  const rows = results.flatMap((result) =>
+    result.status === "fulfilled" && !result.value.value.deleted
+      ? [result.value]
+      : [],
+  );
+  const requests = rows.flatMap((row) =>
+    row.value.threads.flatMap((thread) =>
+      thread.request ? [thread.request] : [],
     ),
+  );
+  const reports: EventData[] = [];
+  // The app reader caps a page at 500. Batch request tokens and refuse a full
+  // page rather than turning an incomplete snapshot into Needs review.
+  for (let offset = 0; offset < requests.length; offset += 100) {
+    const page = await session.snapshotRead(
+      [
+        {
+          kinds: [9],
+          "#h": [channel],
+          "#t": [REVIEW_REPORT],
+          "#r": requests.slice(offset, offset + 100),
+          limit: 500,
+        },
+      ],
+      { signal },
+    );
+    if (page.length >= 500)
+      throw new Error(
+        "Review report read reached its limit. Status could not be loaded completely.",
+      );
+    reports.push(...page);
+  }
+  return {
+    rows: rows.map((row) => applyReviewReports(row, channel, reports)),
     warning: [
       events.length > 100
         ? "Showing results from the latest 100 saved records, including deleted entries."
@@ -160,6 +208,33 @@ export async function loadSubmissions(
   };
 }
 
+/** Shared projection for the initial snapshot and verified live reports. */
+export function applyReviewReports(
+  row: SavedSubmission,
+  channel: string,
+  events: readonly EventData[],
+): SavedSubmission {
+  const reports = [...(row.reviewReports ?? []), ...events];
+  const latest: EventData[] = [];
+  const reviewStates = row.value.threads.map((thread, index): ReviewState => {
+    const lane = submissionLane(row.value, index);
+    if (!thread.request || !thread.id || !lane) return "need_review";
+    const target = {
+      channel,
+      artifact: row.artifactId,
+      request: thread.request,
+      root: thread.id,
+      reviewer: lane.reviewers[0] ?? "",
+      index,
+    };
+    const report = latestReport(reports, target);
+    if (!report) return "need_review";
+    latest.push({ ...report, tags: report.tags.map((tag) => [...tag]) });
+    return reportStatus(report, target) ?? "need_review";
+  });
+  return { ...row, reviewStates, reviewReports: latest };
+}
+
 async function write(
   session: RelaySession,
   channel: string,
@@ -264,6 +339,7 @@ export function threadMessage(
   channel: string,
   index: number,
   reviewerName = "Reviewer",
+  documentation = "",
 ) {
   const lane = submissionLane(value, index);
   const title = `${value.config.repository}#${value.pr}${lane ? ` · ${lane.name}` : " · Review"}`;
@@ -275,7 +351,7 @@ export function threadMessage(
       ...(lane ? [["p", lane.reviewers[0] ?? ""]] : []),
     ],
     content: lane
-      ? `Review request: ${prUrl(value)}\n\nReviewer: ${profileMentionLink(`@${reviewerName}`, `nostr:${npubEncode(lane.reviewers[0] ?? "")}`)}\nLane: ${lane.name}\n\n${lane.instructions}\n\nReply in this thread with the commit you reviewed, findings, and any blockers. Verify the current PR and repository before reviewing. This submission does not pin a commit or post a GitHub review.${value.version === 1 ? `\n\nOverview: ${threadUrl(channel, value.threads[0]?.id ?? "")}` : ""}`
+      ? `Review request: ${prUrl(value)}\n\nReviewer: ${profileMentionLink(`@${reviewerName}`, `nostr:${npubEncode(lane.reviewers[0] ?? "")}`)}\nLane: ${lane.name}\n\n${lane.instructions}${documentation ? `\n\n${documentation}` : ""}\n\nReply in this thread with the commit you reviewed, findings, and any blockers. Verify the current PR and repository before reviewing. This submission does not pin a commit or post a GitHub review.${value.version === 1 ? `\n\nOverview: ${threadUrl(channel, value.threads[0]?.id ?? "")}` : ""}`
       : `Review request: ${prUrl(value)}\n\nLanes: ${value.config.lanes.map((item) => item.name).join(", ")}\n\nLane threads and delivery status are listed in Review Configuration. A delivered request does not mean the reviewer has started. Automatic reminders are off.`,
   };
 }
@@ -372,16 +448,41 @@ async function notifyReviewers(
   record: SavedSubmission,
   signal: AbortSignal,
   reminder = false,
+  documentation = "",
 ) {
   const outbox = session.outbox;
   if (!outbox) throw new Error("Message delivery is unavailable.");
   await eligible(session, record.value, signal);
+  if (record.value.submitter !== session.viewer)
+    throw new Error("Only the original submitter can request another review.");
+  const device = deviceId(session.scope);
+  if (record.value.notifying && record.value.device !== device)
+    throw new Error(
+      "Resume the pending notification from its original browser profile.",
+    );
+  if (!record.value.notifying)
+    record = await write(
+      session,
+      channel,
+      {
+        ...record.value,
+        notifying: true,
+        device,
+        threads: record.value.threads.map((thread, index) =>
+          submissionLane(record.value, index)
+            ? { ...thread, request: crypto.randomUUID() }
+            : thread,
+        ),
+      },
+      record,
+      signal,
+    );
   const receipts: string[] = [];
   for (const [index, thread] of record.value.threads.entries()) {
     const lane = submissionLane(record.value, index);
     if (!lane || !thread.id) continue; // Older submissions also have an overview.
     signal.throwIfAborted();
-    const key = `review-notify:${record.artifactId}:${thread.id}`;
+    const key = `review-notify:${record.artifactId}:${thread.id}:${thread.request}`;
     const recovery = await outbox.recovery(key);
     const active = () => !signal.aborted;
     let id: string;
@@ -400,6 +501,7 @@ async function notifyReviewers(
           .snapshot()
           .selectable.find((choice) => choice.pubkey === lane.reviewers[0])
           ?.name,
+        documentation,
       );
       id = outbox.send(
         {
@@ -409,7 +511,7 @@ async function notifyReviewers(
             ["e", thread.id, "", "reply"],
             ["p", lane.reviewers[0] ?? ""],
           ],
-          content: `${reminder ? "Review reminder. Please review this PR and report your progress or blockers in this thread." : "This PR was submitted again. Please revisit the review in this thread."}\n\n${request.content}`,
+          content: `${reminder ? "Review reminder. Status changed to needs review. Please review this PR and report your findings in this thread." : "This PR was submitted again. Please revisit the review in this thread."}\n\n${request.content}`,
         },
         { key, value: record.artifactId },
         active,
@@ -418,7 +520,10 @@ async function notifyReviewers(
     await delivered(outbox, id, signal);
     receipts.push(id);
   }
+  const { notifying: _notifying, ...value } = record.value;
+  const completed = await write(session, channel, value, record, signal);
   for (const id of receipts) await outbox.acknowledge(id);
+  return completed;
 }
 
 /** An explicit reminder uses only the current, fully delivered submission. */
@@ -428,6 +533,7 @@ export async function remindSubmission(
   previous: SavedSubmission,
   signal: AbortSignal,
   readStatus: ReadPullStatus,
+  documentation = "",
 ) {
   const read = session.snapshotRead;
   const outbox = session.outbox;
@@ -477,7 +583,14 @@ export async function remindSubmission(
         throw new Error(
           "This PR is closed or merged. Reviewers were not reminded.",
         );
-      await notifyReviewers(session, channel, current, signal, true);
+      return notifyReviewers(
+        session,
+        channel,
+        current,
+        signal,
+        true,
+        documentation,
+      );
     },
   );
 }
@@ -494,6 +607,7 @@ export async function submitReview(
   resume = false,
   facts?: PullFacts | (() => Promise<PullFacts>),
   notifyExisting?: () => void,
+  documentation = "",
 ) {
   const outbox = session.outbox;
   const read = session.snapshotRead;
@@ -575,7 +689,9 @@ export async function submitReview(
           configRevision: saved.revision,
           submitter: viewer,
           device,
-          threads: Array.from({ length: config.lanes.length }, () => ({})),
+          threads: Array.from({ length: config.lanes.length }, () => ({
+            request: crypto.randomUUID(),
+          })),
         };
         await eligible(session, value, signal);
         record = await write(session, channel, value, previous, signal);
@@ -585,7 +701,14 @@ export async function submitReview(
       if (existing && !resume && !notifyExisting) return record;
       if (record.value.threads.every((thread) => thread.delivered)) {
         if (existing && notifyExisting)
-          await notifyReviewers(session, channel, record, signal);
+          record = await notifyReviewers(
+            session,
+            channel,
+            record,
+            signal,
+            false,
+            documentation,
+          );
         for (const thread of record.value.threads)
           if (thread.id) await outbox.acknowledge(thread.id);
         return record;
@@ -660,7 +783,13 @@ export async function submitReview(
               {
                 ...record.value,
                 threads: record.value.threads.map((item, i) =>
-                  i === index ? { started: true } : item,
+                  i === index
+                    ? {
+                        ...item,
+                        request: item.request ?? crypto.randomUUID(),
+                        started: true,
+                      }
+                    : item,
                 ),
               },
               record,
@@ -681,6 +810,7 @@ export async function submitReview(
                         choice.pubkey ===
                         submissionLane(record.value, index)?.reviewers[0],
                     )?.name,
+                  documentation,
                 ),
                 { key, value: artifactId },
                 active,
@@ -695,7 +825,11 @@ export async function submitReview(
                   {
                     ...record.value,
                     threads: record.value.threads.map((item, i) =>
-                      i === index ? {} : item,
+                      i === index
+                        ? item.request
+                          ? { request: item.request }
+                          : {}
+                        : item,
                     ),
                   },
                   record,
@@ -716,7 +850,7 @@ export async function submitReview(
               {
                 ...record.value,
                 threads: record.value.threads.map((item, i) =>
-                  i === index ? { id: sentId } : item,
+                  i === index ? { ...item, id: sentId } : item,
                 ),
               },
               record,
@@ -735,7 +869,9 @@ export async function submitReview(
           {
             ...record.value,
             threads: record.value.threads.map((item, i) =>
-              i === index ? { id: deliveredId, delivered: true } : item,
+              i === index
+                ? { ...item, id: deliveredId, delivered: true }
+                : item,
             ),
           },
           record,
diff --git a/src/buzz-mcp/client.ts b/src/buzz-mcp/client.ts
index 4ddf289043..69e3401fe5 100644
--- a/src/buzz-mcp/client.ts
+++ b/src/buzz-mcp/client.ts
@@ -191,6 +191,9 @@ export interface BuzzClient {
  * this channel's messages out of threads. With no `root`, or with
  * `wholeChannel`, its session is the whole channel. */
 export type Context = Readonly<{
+  /** Review thread supplied by the host, never tool arguments.
+   * Keep immutable across steering and discard when the turn ends. */
+  review?: Readonly<{ channel: string; root: string }>;
   channel?: string;
   root?: string;
   topLevel?: boolean;
diff --git a/src/buzz-mcp/main.ts b/src/buzz-mcp/main.ts
index e8f1540949..bdbcae0029 100644
--- a/src/buzz-mcp/main.ts
+++ b/src/buzz-mcp/main.ts
@@ -3,6 +3,7 @@
 //   BUZZ_RELAY_URL, BUZZ_PRIVATE_KEY, BUZZ_AUTH_TAG
 // plus BUZZ_CHANNEL, the channel tools default to, and BUZZ_MCP_ROOT, the only
 // directory `path` and `files` may read (default: the working directory).
+// Hosts with a process dedicated to one review thread may also set BUZZ_REVIEW_THREAD.
 import { fromJsonSchema, McpServer } from "@modelcontextprotocol/server";
 import { serveStdio } from "@modelcontextprotocol/server/stdio";
 import { nodeClient, relayAuthorityLookup } from "./node";
@@ -31,7 +32,17 @@ const client = nodeClient({
   ...(auth ? { auth } : {}),
   root: process.env.BUZZ_MCP_ROOT?.trim() || process.cwd(),
 });
-const context = channel ? { channel } : {};
+// A host may bind this MCP process to one review thread for its whole lifetime.
+// Channel-wide/reused-across-thread sessions must omit BUZZ_REVIEW_THREAD.
+const reviewRoot = process.env.BUZZ_REVIEW_THREAD?.trim();
+const context = channel
+  ? {
+      channel,
+      ...(reviewRoot && /^[0-9a-f]{64}$/.test(reviewRoot)
+        ? { root: reviewRoot, review: { channel, root: reviewRoot } }
+        : {}),
+    }
+  : {};
 
 serveStdio(() => {
   const server = new McpServer(
diff --git a/src/buzz-mcp/pr-review.ts b/src/buzz-mcp/pr-review.ts
new file mode 100644
index 0000000000..4dd40cab29
--- /dev/null
+++ b/src/buzz-mcp/pr-review.ts
@@ -0,0 +1,111 @@
+import type { BuzzClient, Context } from "./client";
+import {
+  REVIEW_REPORT,
+  REVIEW_SUBMISSION,
+  latestReport,
+  reportStatus,
+  reportSequence,
+  reviewTarget,
+} from "../features/agents/pr-review";
+
+export async function updateReviewStatus(
+  client: BuzzClient,
+  context: Context,
+  args: Readonly<Record<string, unknown>>,
+) {
+  if (
+    Object.keys(args).some((key) => key !== "status") ||
+    (args.status !== "done" && args.status !== "wait_author")
+  )
+    throw new Error(
+      "Only status: done or wait_author is accepted. Buzz supplies the review target.",
+    );
+  const binding = context.review;
+  if (!binding)
+    throw new Error(
+      "This host has not supplied a review turn. No status was changed.",
+    );
+  const heads = await client.query([
+    {
+      kinds: [45010],
+      "#h": [binding.channel],
+      "#type": [REVIEW_SUBMISSION],
+      artifact: "current",
+      limit: 101,
+    },
+  ]);
+  if (heads.length > 100)
+    throw new Error("Too many submissions to resolve this review safely.");
+  const matches = await Promise.allSettled(
+    heads.map((head) =>
+      reviewTarget(head, binding.channel, binding.root, client.pubkey),
+    ),
+  );
+  const targets = matches.flatMap((match) =>
+    match.status === "fulfilled" ? [match.value] : [],
+  );
+  const target = targets[0];
+  if (targets.length !== 1 || !target)
+    throw new Error("This thread has no unique active review assigned to you.");
+  const current = async () => {
+    const head = (
+      await client.query([
+        {
+          kinds: [45010],
+          "#h": [binding.channel],
+          "#d": [target.artifact],
+          artifact: "current",
+          limit: 1,
+        },
+      ])
+    )[0];
+    if (!head) throw new Error("The review submission is unavailable.");
+    const latest = await reviewTarget(
+      head,
+      binding.channel,
+      binding.root,
+      client.pubkey,
+    );
+    if (latest.request !== target.request)
+      throw new Error(
+        "The review changed during this update. No result applies to the new request.",
+      );
+  };
+  const reports = await client.query([
+    {
+      kinds: [9],
+      authors: [client.pubkey],
+      "#h": [target.channel],
+      "#t": [REVIEW_REPORT],
+      "#r": [target.request],
+      limit: 100,
+      consistency: "strong",
+    },
+  ]);
+  if (reports.length >= 100)
+    throw new Error(
+      "Review report history reached its read limit. Request a new review before reporting again.",
+    );
+  const previous = latestReport(reports, target);
+  await current();
+  if (previous && reportStatus(previous, target) === args.status)
+    return `Review status already saved: ${args.status}.`;
+  client.signal?.throwIfAborted();
+  await client.publish({
+    kind: 9,
+    tags: [
+      ["h", target.channel],
+      ["e", target.root, "", "reply"],
+      ["t", REVIEW_REPORT],
+      ["r", target.request],
+      ["review", target.artifact, String(target.index)],
+      ["status", args.status],
+      ["review-sequence", String(previous ? reportSequence(previous) + 1 : 1)],
+    ],
+    content: `Review status: ${args.status === "done" ? "Done" : "Waiting on author"}.`,
+  });
+  // A reset can race publication. Its old request token is never projected into
+  // the new round; tell the caller when that happened rather than claiming success.
+  await current();
+  return `Review status saved: ${args.status}.`;
+}
diff --git a/src/buzz-mcp/session-tools.test.ts b/src/buzz-mcp/session-tools.test.ts
index 3552ecb74c..0e7c14ba95 100644
--- a/src/buzz-mcp/session-tools.test.ts
+++ b/src/buzz-mcp/session-tools.test.ts
@@ -7,6 +7,7 @@ import {
   addedKey,
   sessionHint,
   sessionTools,
+  describeTool,
 } from "./session-tools";
 import { TOOLS } from "./tools";
 import type { ProtectionAction } from "../features/agent-protection/service";
@@ -18,6 +19,27 @@ const tool = (name: string, description = "Does it."): AddedTool => ({
   call: async () => "done",
 });
 
+it("reads current tool documentation without exposing handlers or mutable registry data", () => {
+  const added = tool("tasks_create");
+  const description = describeTool(added.name, [added]);
+  expect(description).toEqual({
+    name: added.name,
+    description: added.description,
+    inputSchema: added.inputSchema,
+  });
+  expect(description).not.toHaveProperty("call");
+  expect(description?.inputSchema).not.toBe(added.inputSchema);
+  expect(describeTool(added.name)).toBeUndefined();
+  expect(describeTool("send")?.description).toBe(
+    TOOLS.find((entry) => entry.name === "send")?.description,
+  );
+  expect(
+    describeTool(added.name, [
+      { ...added, description: "Updated instructions" },
+    ])?.description,
+  ).toBe("Updated instructions");
+});
+
 it("keys the added tools whatever order plugins started in", () => {
   expect(addedKey([])).toBe("");
   const key = addedKey([tool("notes_add"), tool("tasks_create")]);
diff --git a/src/buzz-mcp/session-tools.ts b/src/buzz-mcp/session-tools.ts
index 098e4f6113..c3b649b004 100644
--- a/src/buzz-mcp/session-tools.ts
+++ b/src/buzz-mcp/session-tools.ts
@@ -44,7 +44,11 @@ export type AddedTool = Readonly<{
     args: Record<string, unknown>,
   ): Promise<Reply>;
 }>;
-type Listed = Pick<AddedTool, "name" | "description" | "inputSchema">;
+export type ToolDescription = Pick<
+  AddedTool,
+  "name" | "description" | "inputSchema"
+>;
+type Listed = ToolDescription;
 
 export {
   isFinalMessage,
@@ -68,7 +72,7 @@ export const BUZZ_SESSION: BuzzSession = Object.freeze({
   ],
 });
 
-const listed = ({ name, description, inputSchema }: AddedTool): Listed => ({
+const listed = ({ name, description, inputSchema }: Listed): Listed => ({
   name,
   description,
   inputSchema,
@@ -93,6 +97,16 @@ export const sessionTools = (
   ...added.map((tool) => ({ ...listed(tool), load: "search" as const })),
 ];
 
+/** Read-only metadata for plugins composing instructions. Never exposes a
+ * handler or a mutable reference to the runtime's tool definition. */
+export function describeTool(
+  name: string,
+  added: readonly AddedTool[] = [],
+): ToolDescription | undefined {
+  const tool = sessionTools(added).find((entry) => entry.name === name);
+  return tool ? structuredClone(listed(tool)) : undefined;
+}
+
 /** What the server (Claude) or namespace (Codex) with the tools says up
  * front, so the model knows what it can search for. */
 export function sessionHint(added: readonly AddedTool[] = []) {
diff --git a/src/buzz-mcp/tools.ts b/src/buzz-mcp/tools.ts
index a640c2d3d7..dd6782a7d5 100644
--- a/src/buzz-mcp/tools.ts
+++ b/src/buzz-mcp/tools.ts
@@ -1,4 +1,5 @@
 import { messageAuthor } from "../features/relay/fold";
+import { updateReviewStatus } from "./pr-review";
 // The Buzz tools: what an agent does in Buzz, in the wire formats the `buzz`
 // CLI writes. Names, arguments and descriptions are kept short because every
 // session pays for them in context. Each tool answers in plain text.
@@ -139,6 +140,13 @@ export async function captureToolBody(
 }
 
 export const TOOLS: readonly Tool[] = [
+  tool(
+    "pr_review_status_update",
+    "Record the result of the current PR review assigned to you in this thread. After posting findings, call with done when no author action remains, or wait_author when changes are needed. Buzz supplies the exact review request; never supply a PR, thread or request ID. Only consider status saved after success. Missing or stale review context is refused; explain the blocker in the thread if unavailable.",
+    { status: { type: "string", enum: ["done", "wait_author"] } },
+    ["status"],
+    { readOnlyHint: false, destructiveHint: false },
+  ),
   tool(
     "buzz_help",
     "Read the bundled guide to using Buzz: chats, communities, identity, agents, and settings.",
@@ -480,6 +488,8 @@ export function callTool(
 }
 
 const HANDLERS: Readonly<Record<string, Handler>> = {
+  pr_review_status_update: ({ client, context }, args) =>
+    updateReviewStatus(client, context, args),
   async buzz_help() {
     return buzzHelp.trim();
   },
diff --git a/src/features/agent-harness/kit.test.ts b/src/features/agent-harness/kit.test.ts
index 1f1bcba444..cb9208d02a 100644
--- a/src/features/agent-harness/kit.test.ts
+++ b/src/features/agent-harness/kit.test.ts
@@ -486,3 +486,30 @@ describe("harnessKit.tools", () => {
     );
   });
 });
+
+it("only admits review updates from a host-bound thread conversation", async () => {
+  const { kit, agent, delivery } = setup();
+  const event = reply("2", "1", "review");
+  const thread = await kit.conversation(
+    delivery({ type: "mention", event }),
+    "thread",
+  );
+  const channelConversation = await kit.conversation(
+    delivery({ type: "mention", event }),
+    "channel",
+  );
+  const call = {
+    jsonrpc: "2.0",
+    id: 1,
+    method: "tools/call",
+    params: { name: "pr_review_status_update", arguments: { status: "done" } },
+  };
+  const missing = await kit.tools(agent, channelConversation)(call);
+  expect(JSON.stringify(missing)).toContain("host has not supplied");
+  expect(agent.query).not.toHaveBeenCalled();
+  const bound = await kit.tools(agent, thread)(call);
+  expect(JSON.stringify(bound)).toContain("no unique active review");
+  expect(agent.query).toHaveBeenCalledWith([
+    expect.objectContaining({ "#h": [channel], artifact: "current" }),
+  ]);
+});
diff --git a/src/features/agent-harness/kit.ts b/src/features/agent-harness/kit.ts
index 56f76c7b28..087a111620 100644
--- a/src/features/agent-harness/kit.ts
+++ b/src/features/agent-harness/kit.ts
@@ -453,9 +453,26 @@ export function harnessKit(sources: Sources): HarnessKit {
           },
         });
         const added = sources.added();
-        return respond(client, context, message, added, {
-          instructions: sessionHint(added),
-        });
+        const admitted = conversation && known(conversation);
+        return respond(
+          client,
+          {
+            ...context,
+            ...(admitted && !admitted.wake && conversation.root
+              ? {
+                  review: {
+                    channel: conversation.channel,
+                    root: conversation.root,
+                  },
+                }
+              : {}),
+          },
+          message,
+          added,
+          {
+            instructions: sessionHint(added),
+          },
+        );
       };
     },
 
diff --git a/src/features/agents/pr-review.ts b/src/features/agents/pr-review.ts
new file mode 100644
index 0000000000..7e2e7ca3fd
--- /dev/null
+++ b/src/features/agents/pr-review.ts
@@ -0,0 +1,121 @@
+import type { BuzzEvent } from "../../buzz-mcp/client";
+import { uuidv5 } from "./agent-config-artifacts";
+
+export const REVIEW_SUBMISSION = "buzz.review.submission";
+export const REVIEW_REPORT = "buzz.review.status";
+export type ReviewStatus = "done" | "wait_author";
+export type ReviewState = ReviewStatus | "need_review";
+type Event = Pick<
+  BuzzEvent,
+  "kind" | "id" | "pubkey" | "tags" | "content" | "created_at"
+>;
+const hex = /^[0-9a-f]{64}$/;
+export const reviewToken = /^[0-9a-f-]{36}$/;
+export const reviewTag = (event: Event, name: string) =>
+  event.tags.find((tag) => tag[0] === name)?.[1];
+
+export type ReviewTarget = Readonly<{
+  channel: string;
+  artifact: string;
+  request: string;
+  root: string;
+  reviewer: string;
+  index: number;
+}>;
+
+/** One active review per lane thread. Resolve its current request from the
+ * submitter-owned artifact; the model never chooses a target. */
+export async function reviewTarget(
+  head: Event,
+  channel: string,
+  root: string,
+  reviewer: string,
+): Promise<ReviewTarget> {
+  const value = JSON.parse(head.content);
+  const matches = Array.isArray(value?.threads)
+    ? value.threads.flatMap((thread: { id?: string }, index: number) =>
+        thread?.id === root ? [index] : [],
+      )
+    : [];
+  const index = matches[0];
+  const artifact = reviewTag(head, "d");
+  const thread = value?.threads?.[index];
+  const lane = value?.config?.lanes?.[index - (value.version === 1 ? 1 : 0)];
+  if (
+    matches.length !== 1 ||
+    !artifact ||
+    head.kind !== 45010 ||
+    reviewTag(head, "h") !== channel ||
+    reviewTag(head, "type") !== REVIEW_SUBMISSION ||
+    ![1, 2, 3].includes(value.version) ||
+    value.deleted ||
+    value.submitter !== head.pubkey ||
+    !hex.test(root) ||
+    !Number.isSafeInteger(value.pr) ||
+    value.pr < 1 ||
+    typeof value.config?.repository !== "string" ||
+    !Array.isArray(lane?.reviewers) ||
+    lane.reviewers.length !== 1 ||
+    lane.reviewers[0] !== reviewer ||
+    typeof thread?.request !== "string" ||
+    !reviewToken.test(thread.request) ||
+    (await uuidv5(
+      channel,
+      `${REVIEW_SUBMISSION}:${value.config.repository}:${value.pr}`,
+    )) !== artifact
+  )
+    throw new Error(
+      "Review thread is unavailable or assigned to another reviewer.",
+    );
+  return { channel, artifact, request: thread.request, root, reviewer, index };
+}
+
+export function reportStatus(
+  event: Event,
+  target: ReviewTarget,
+): ReviewStatus | undefined {
+  const status = reviewTag(event, "status");
+  const sequence = reportSequence(event);
+  const marker = event.tags.find((tag) => tag[0] === "review");
+  if (
+    !Number.isSafeInteger(sequence) ||
+    sequence < 1 ||
+    event.kind !== 9 ||
+    event.pubkey !== target.reviewer ||
+    reviewTag(event, "h") !== target.channel ||
+    reviewTag(event, "t") !== REVIEW_REPORT ||
+    reviewTag(event, "r") !== target.request ||
+    marker?.[1] !== target.artifact ||
+    marker[2] !== String(target.index) ||
+    !event.tags.some(
+      (tag) => tag[0] === "e" && tag[1] === target.root && tag[3] === "reply",
+    ) ||
+    (status !== "done" && status !== "wait_author")
+  )
+    return undefined;
+  return status;
+}
+
+export const reportSequence = (event: Event) =>
+  Number(reviewTag(event, "review-sequence"));
+
+export function latestReport(events: readonly Event[], target: ReviewTarget) {
+  return events
+    .filter((event) => reportStatus(event, target))
+    .sort(
+      (a, b) =>
+        reportSequence(b) - reportSequence(a) ||
+        b.created_at - a.created_at ||
+        a.id.localeCompare(b.id),
+    )[0];
+}
+
+export function overallReviewStatus(
+  states: readonly ReviewState[],
+): ReviewState {
+  return states.includes("wait_author")
+    ? "wait_author"
+    : states.length && states.every((status) => status === "done")
+      ? "done"
+      : "need_review";
+}
diff --git a/src/features/agents/service.test.ts b/src/features/agents/service.test.ts
index cf25c2350d..db49421d96 100644
--- a/src/features/agents/service.test.ts
+++ b/src/features/agents/service.test.ts
@@ -10882,6 +10882,13 @@ it("adds plugins' tools to every session, each name once", async () => {
   expect(service.tools()).toMatchObject([
     { name: "notes_add", pluginId: "example" },
   ]);
+  expect(plugin.agents.describeTool("notes_add")).toEqual({
+    name: "notes_add",
+    description: tool.description,
+    inputSchema: tool.inputSchema,
+  });
+  expect(plugin.agents.describeTool("send")?.name).toBe("send");
+  expect(plugin.agents.describeTool("missing")).toBeUndefined();
   const bundled = (id: string) =>
     ctx.extend({ pluginOwner: Object.freeze({ id, revision: "bundled" }) });
   const tasks = bundled("buzz.tasks");
diff --git a/src/features/agents/service.ts b/src/features/agents/service.ts
index 394e56234d..aadecce625 100644
--- a/src/features/agents/service.ts
+++ b/src/features/agents/service.ts
@@ -192,7 +192,12 @@ import {
 } from "./catch-up";
 import { readInterrupted, writeInterrupted } from "./interrupted";
 import { AttentionSources, type AttentionProducer } from "./attention-sources";
-import { type AddedTool, BUZZ_SESSION } from "../../buzz-mcp/session-tools";
+import {
+  type AddedTool,
+  BUZZ_SESSION,
+  describeTool,
+  type ToolDescription,
+} from "../../buzz-mcp/session-tools";
 import { nameSoloChat } from "./solo-chat-name";
 import { visibleTeams } from "./visible-teams";
 import {
@@ -1316,6 +1321,8 @@ export type Agents = {
   addTool(tool: AddedTool): void;
   /** The tools active plugins add now. A name is only ever one plugin's. */
   tools(): readonly AddedTool[];
+  /** Current tool documentation, without a handler. Includes built-in tools. */
+  describeTool(name: string): ToolDescription | undefined;
   /** The Buzz side of a turn for an agent type a plugin brings: where a
    * delivery goes, the bundled harnesses' prompts, the agent's Buzz tools as
    * an MCP handler, and its replies. */
@@ -2724,6 +2731,9 @@ export class AgentsService extends Service implements Agents {
       return () => this.toolNames.delete(tool.name);
     });
   }
+  describeTool(name: string) {
+    return describeTool(name, this.tools());
+  }
   addAttentionSource(source: import("./attention-sources").AttentionSource) {
     const plugin = this.ctx.pluginOwner?.id;
     if (

From 6f3b0ab34a1507dfda58cfe2a51bd77a1e537725 Mon Sep 17 00:00:00 2001
From: Ravneet Arora <rarora@squareup.com>
Date: Thu, 12 Nov 2026 18:47:31 -0500
Subject: [PATCH 16/17] Document ACP review context handoff

Co-authored-by: maincourse <37ce551b493d4a998caf030929c47bce0b6a0e43f1178b3a63c4151d7c16b76e@buzz.block.builderlab.xyz>
Signed-off-by: Ravneet Arora <rarora@squareup.com>
---
 src/bundled/review-configuration/README.md | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/bundled/review-configuration/README.md b/src/bundled/review-configuration/README.md
index d066083e94..5edf8d03ec 100644
--- a/src/bundled/review-configuration/README.md
+++ b/src/bundled/review-configuration/README.md
@@ -193,5 +193,6 @@ A standalone MCP host can set `BUZZ_CHANNEL` and `BUZZ_REVIEW_THREAD` when start
 a process dedicated to that thread. Never reuse that process across threads.
 Channel-wide sessions, external MCP, and adapters without this host wiring refuse
 status updates. Merely including a thread ID in the prompt does not enable it.
-The existing standalone ACP lab launcher still needs that environment wiring;
-this feature does not add it to every adapter automatically.
+ACP hosts must pass those variables when creating each thread session and
+recreate existing sessions after adding the wiring. Updating MCP alone does not
+provide review context.

From 921fb9be7d277c6b5fe5d5a13cc2c24b1119ccd2 Mon Sep 17 00:00:00 2001
From: Ravneet Arora <rarora@squareup.com>
Date: Thu, 12 Nov 2026 19:09:26 -0500
Subject: [PATCH 17/17] Register review plugin in native catalog

Co-authored-by: maincourse <37ce551b493d4a998caf030929c47bce0b6a0e43f1178b3a63c4151d7c16b76e@buzz.block.builderlab.xyz>
Signed-off-by: Ravneet Arora <rarora@squareup.com>
---
 crates/plugin-manager/src/lib.rs          | 4 ++++
 crates/plugin-manager/tests/management.rs | 1 +
 2 files changed, 5 insertions(+)

diff --git a/crates/plugin-manager/src/lib.rs b/crates/plugin-manager/src/lib.rs
index 886686c234..4383b7b49e 100644
--- a/crates/plugin-manager/src/lib.rs
+++ b/crates/plugin-manager/src/lib.rs
@@ -542,6 +542,10 @@ pub fn bundled_manifests() -> Vec<Manifest> {
             "../../../src/bundled/changesets/manifest.json"
         ))
         .expect("changesets manifest"),
+        serde_json::from_str(include_str!(
+            "../../../src/bundled/review-configuration/manifest.json"
+        ))
+        .expect("review configuration manifest"),
     ]
 }
 /// New bundles must opt in to the default-on policy.
diff --git a/crates/plugin-manager/tests/management.rs b/crates/plugin-manager/tests/management.rs
index c570282057..9aaadb9eff 100644
--- a/crates/plugin-manager/tests/management.rs
+++ b/crates/plugin-manager/tests/management.rs
@@ -1384,6 +1384,7 @@ fn bundled_defaults_preserve_saved_choices_and_only_channels_is_required() {
                 | "buzz.drafts-and-sent"
                 | "buzz.changesets"
                 | "buzz.charts"
+                | "buzz.review-configuration"
         );
         assert_eq!(plugin.enabled, default, "{id}");
         if id == "buzz.channels" {