diff --git a/plugins/guided-review/README.md b/plugins/guided-review/README.md
index 273b283..7eaa244 100644
--- a/plugins/guided-review/README.md
+++ b/plugins/guided-review/README.md
@@ -38,18 +38,29 @@ To guide the branch you already have checked out, choose **Guided Review: guide
 If your branch is clean and behind the PR/MR, the plugin fast-forwards it and writes the guide in your workspace.
 Otherwise it leaves your branch alone and uses a new workspace.
 
-### Pick from your review requests
+### Pick from your review requests or your own
 
-**Assigned to me for review** lists the open pull requests and merge requests you are a reviewer of, on github.com and on every GitLab host `glab` is logged in to.
+The start tab lists open pull requests and merge requests in two tabs.
+**Assigned to me** lists the ones you are a reviewer of, on github.com and on every GitLab host `glab` is logged in to.
+**Authored by me** lists your own on the same hosts, drafts included.
+Its review status combines your reviewers' latest verdicts, and changes requested by any reviewer outweigh approvals.
+An approval GitLab removes, or GitHub dismisses, when you push shows as an approval reset.
+On GitLab, an approval its reviewer revokes shows as an approval reset too.
+A merge request you wrote and review is on both tabs, with the one review you started from either.
 
 - Select **Review** to start a review, **Open** to open one, or **Continue** to reopen one whose workspace was closed.
-- Filter by forge, by state under **States**, with **Needs my attention** or **Hide drafts**, or search.
+- Filter by forge, by state under **States**, with **Needs my attention** or with **Hide drafts**, or search.
+  On **Authored by me**, the search also matches reviewers.
+  On **Authored by me**, **Needs my attention** keeps changes requested, a review since your last push, and failing CI.
 - Select a column heading to sort, and **Columns** to choose what the table shows.
+- Each tab keeps its own filters, sort, columns and search.
 - Tick a row's box to check it off while it waits on someone else.
-  It comes back when someone pushes to it, asks you to review again, or GitLab resets your approval.
-- Select **Refresh** to list again.
+  On **Assigned to me**, it comes back when someone pushes to it, asks you to review again, or GitLab resets your approval.
+  On **Authored by me**, it comes back when a reviewer reviews again or its review status changes, an approval reset included, but not when you push.
+  A check-off on one tab leaves the other tab alone.
+- Select **Refresh** to list both tabs again.
 
-The count beside **Guided Review** in the sidebar is how many reviews need your attention.
+The count beside **Guided Review** in the sidebar is how many review requests on **Assigned to me** need your attention.
 
 If a review workspace shows no panel, select **Open Guided Review** in the workspace's header.
 
diff --git a/plugins/guided-review/client/check-off.ts b/plugins/guided-review/client/check-off.ts
index 51066b2..79dc1d3 100644
--- a/plugins/guided-review/client/check-off.ts
+++ b/plugins/guided-review/client/check-off.ts
@@ -3,40 +3,54 @@ import { useIsMutating, useMutation, useQueryClient } from "@tanstack/react-quer
 import { createContext, useState } from "react";
 import * as contracts from "../shared/contracts.ts";
 import { PLUGIN_ID } from "../shared/identity.ts";
-import type { Inbox, InboxItem } from "../shared/inbox.ts";
+import type { AuthoredInboxItem, CheckOffChange, Inbox, InboxItem } from "../shared/inbox.ts";
+import { withCheckedOff, type ListedItem } from "./inbox-filter.ts";
 
 export const INBOX_QUERY_KEY = [PLUGIN_ID, "inbox"];
 const MUTATION_KEY = [PLUGIN_ID, "check-off"];
 
-export type CheckOffControl = {
-  toggle(item: InboxItem): void;
+/** What a tab's check-off records of its row, so the server can tell when it came back. */
+export type CheckOffRule<Item extends ListedItem> = (item: Item, checkedOff: boolean) => CheckOffChange;
+
+export const ASSIGNED_CHECK_OFF: CheckOffRule<InboxItem> = (item, checkedOff) => ({
+  tab: "assigned",
+  url: item.url,
+  checkOff: checkedOff ? { headSha: item.headSha, state: item.state } : null,
+});
+
+export const AUTHORED_CHECK_OFF: CheckOffRule<AuthoredInboxItem> = (item, checkedOff) => ({
+  tab: "authored",
+  url: item.url,
+  checkOff: checkedOff ? { status: item.status, latestReviewAt: item.latestReviewAt } : null,
+});
+
+export type CheckOffControl<Item extends ListedItem> = {
+  toggle(item: Item): void;
   /** The rows checked off or unchecked since the list was last refreshed, filtered or searched, which stay where they are until then. */
   held: ReadonlySet<string>;
   release(): void;
-  /** A check-off is being saved, so a refresh now could read the list from before it. */
+  /** A check-off on either tab is being saved, so a refresh now could read the list from before it. */
   saving: boolean;
   /** Why the latest check-off could not be kept, as a sentence. */
   error: string | null;
 };
 
 /**
- * Checking reviews off the list and unchecking them.
+ * Checking change requests off one tab of the list and unchecking them.
  * A toggle shows at once in the listed inbox and is saved behind it, and put back if the save fails.
  */
-export function useCheckOff(): CheckOffControl {
+export function useCheckOff<Item extends ListedItem>(rule: CheckOffRule<Item>): CheckOffControl<Item> {
   const setCheckedOff = useRpc(contracts.setCheckedOff);
   const queryClient = useQueryClient();
   const [held, setHeld] = useState<ReadonlySet<string>>(() => new Set());
   const [error, setError] = useState<string | null>(null);
-  const mark = (url: string, checkedOff: boolean) =>
-    queryClient.setQueryData<Inbox>(INBOX_QUERY_KEY, (inbox) =>
-      inbox && { ...inbox, items: inbox.items.map((item) => (item.url === url ? { ...item, checkedOff } : item)) },
-    );
+  const mark = ({ tab, url }: CheckOffChange, checkedOff: boolean) =>
+    queryClient.setQueryData<Inbox>(INBOX_QUERY_KEY, (inbox) => inbox && withCheckedOff(inbox, tab, url, checkedOff));
   const save = useMutation({
     mutationKey: MUTATION_KEY,
     mutationFn: setCheckedOff,
-    onError: (failure, { url, checkOff }) => {
-      mark(url, checkOff === null);
+    onError: (failure, change) => {
+      mark(change, change.checkOff === null);
       setError(failure instanceof Error ? failure.message : String(failure));
     },
   });
@@ -45,11 +59,12 @@ export function useCheckOff(): CheckOffControl {
   return {
     toggle(item) {
       const checkedOff = !item.checkedOff;
+      const change = rule(item, checkedOff);
       void queryClient.cancelQueries({ queryKey: INBOX_QUERY_KEY });
-      mark(item.url, checkedOff);
+      mark(change, checkedOff);
       setHeld((rows) => new Set(rows).add(item.url));
       setError(null);
-      save.mutate({ url: item.url, checkOff: checkedOff ? { headSha: item.headSha, state: item.state } : null });
+      save.mutate(change);
     },
     held,
     release: () => setHeld(new Set()),
@@ -59,7 +74,7 @@ export function useCheckOff(): CheckOffControl {
 }
 
 /** What a row's checkbox needs from the list, so the column's cell takes no more than every other cell. */
-export const CheckOffContext = createContext<{ toggle(item: InboxItem): void; dimmed(item: InboxItem): boolean }>({
+export const CheckOffContext = createContext<{ toggle(item: ListedItem): void; dimmed(item: ListedItem): boolean }>({
   toggle: () => {},
   dimmed: () => false,
 });
diff --git a/plugins/guided-review/client/inbox-filter.test.ts b/plugins/guided-review/client/inbox-filter.test.ts
index ab5c788..25c618c 100644
--- a/plugins/guided-review/client/inbox-filter.test.ts
+++ b/plugins/guided-review/client/inbox-filter.test.ts
@@ -1,8 +1,22 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import { DEFAULT_INBOX_PREFERENCES, type InboxPreferences } from "../shared/inbox-preferences.ts";
-import type { InboxItem } from "../shared/inbox.ts";
-import { age, attentionCount, countLabel, hiddenCheckedOff, matchesSearch, needsAttention, statesLabel, visibleItems } from "./inbox-filter.ts";
+import { DEFAULT_INBOX_PREFERENCES, type AssignedPreferences } from "../shared/inbox-preferences.ts";
+import { ReviewStatusSchema, type AuthoredInboxItem, type Inbox, type InboxItem } from "../shared/inbox.ts";
+import {
+  age,
+  ASSIGNED_RULES,
+  attentionCount,
+  AUTHORED_RULES,
+  countLabel,
+  hiddenCheckedOff,
+  matchesSearch,
+  needsAttention,
+  statesLabel,
+  statusesLabel,
+  tabLabel,
+  visibleItems,
+  withCheckedOff,
+} from "./inbox-filter.ts";
 
 function item(number: number, overrides: Partial<InboxItem> = {}): InboxItem {
   return {
@@ -32,9 +46,9 @@ function item(number: number, overrides: Partial<InboxItem> = {}): InboxItem {
   };
 }
 
-const ALL: InboxPreferences = { ...DEFAULT_INBOX_PREFERENCES, states: ["requested", "commented", "changes-requested", "approved", "unapproved"] };
+const ALL: AssignedPreferences = { ...DEFAULT_INBOX_PREFERENCES.assigned, states: ["requested", "commented", "changes-requested", "approved", "unapproved"] };
 
-function numbers(items: InboxItem[]): number[] {
+function numbers(items: readonly { number: number }[]): number[] {
   return items.map((entry) => entry.number);
 }
 
@@ -45,8 +59,8 @@ test("by default the newest update comes first and what the reviewer approved is
     item(3, { updatedAt: "2026-09-02T00:00:00Z" }),
   ];
 
-  assert.deepEqual(numbers(visibleItems(items, DEFAULT_INBOX_PREFERENCES, "")), [3, 1]);
-  assert.deepEqual(numbers(visibleItems(items, ALL, "")), [2, 3, 1]);
+  assert.deepEqual(numbers(visibleItems(ASSIGNED_RULES, items, DEFAULT_INBOX_PREFERENCES.assigned, "")), [3, 1]);
+  assert.deepEqual(numbers(visibleItems(ASSIGNED_RULES, items, ALL, "")), [2, 3, 1]);
 });
 
 test("filters by forge and drafts, and sorts by creation or size either way", () => {
@@ -56,9 +70,9 @@ test("filters by forge and drafts, and sorts by creation or size either way", ()
     item(3, { createdAt: "2026-08-02T00:00:00Z", additions: 1, deletions: 1 }),
   ];
 
-  assert.deepEqual(numbers(visibleItems(items, { ...ALL, provider: "gitlab" }, "")), [1]);
-  assert.deepEqual(numbers(visibleItems(items, { ...ALL, hideDrafts: true, sort: { key: "created", descending: true } }, "")), [3, 1]);
-  assert.deepEqual(numbers(visibleItems(items, { ...ALL, sort: { key: "size", descending: false } }, "")), [3, 1, 2]);
+  assert.deepEqual(numbers(visibleItems(ASSIGNED_RULES, items, { ...ALL, provider: "gitlab" }, "")), [1]);
+  assert.deepEqual(numbers(visibleItems(ASSIGNED_RULES, items, { ...ALL, hideDrafts: true, sort: { key: "created", descending: true } }, "")), [3, 1]);
+  assert.deepEqual(numbers(visibleItems(ASSIGNED_RULES, items, { ...ALL, sort: { key: "size", descending: false } }, "")), [3, 1, 2]);
 });
 
 test("shows only the reviewer states chosen, updated since or not", () => {
@@ -69,36 +83,36 @@ test("shows only the reviewer states chosen, updated since or not", () => {
     item(4, { state: "requested", changedSinceReview: true }),
   ];
 
-  assert.deepEqual(numbers(visibleItems(items, { ...ALL, states: ["requested"] }, "")), [1, 4]);
-  assert.deepEqual(numbers(visibleItems(items, { ...ALL, states: ["commented", "changes-requested"] }, "")), [2, 3]);
+  assert.deepEqual(numbers(visibleItems(ASSIGNED_RULES, items, { ...ALL, states: ["requested"] }, "")), [1, 4]);
+  assert.deepEqual(numbers(visibleItems(ASSIGNED_RULES, items, { ...ALL, states: ["commented", "changes-requested"] }, "")), [2, 3]);
 });
 
 test("checked-off items are hidden by default, shown among the rest, or shown alone", () => {
   const items = [item(1), item(2, { checkedOff: true }), item(3, { checkedOff: true, isDraft: true })];
 
-  assert.deepEqual(numbers(visibleItems(items, ALL, "")), [1]);
-  assert.deepEqual(numbers(visibleItems(items, { ...ALL, checkedOff: "show" }, "")), [1, 2, 3]);
-  assert.deepEqual(numbers(visibleItems(items, { ...ALL, checkedOff: "only" }, "")), [2, 3]);
-  assert.deepEqual(numbers(visibleItems(items, { ...ALL, checkedOff: "only", hideDrafts: true }, "")), [2], "with the other filters as well");
+  assert.deepEqual(numbers(visibleItems(ASSIGNED_RULES, items, ALL, "")), [1]);
+  assert.deepEqual(numbers(visibleItems(ASSIGNED_RULES, items, { ...ALL, checkedOff: "show" }, "")), [1, 2, 3]);
+  assert.deepEqual(numbers(visibleItems(ASSIGNED_RULES, items, { ...ALL, checkedOff: "only" }, "")), [2, 3]);
+  assert.deepEqual(numbers(visibleItems(ASSIGNED_RULES, items, { ...ALL, checkedOff: "only", hideDrafts: true }, "")), [2], "with the other filters as well");
 });
 
 test("a held row stays whatever the check-off filter says, but not past the other filters", () => {
   const items = [item(1), item(2, { checkedOff: true }), item(3, { checkedOff: true, isDraft: true })];
   const held = new Set(items.map((entry) => entry.url));
 
-  assert.deepEqual(numbers(visibleItems(items, ALL, "", held)), [1, 2, 3]);
-  assert.deepEqual(numbers(visibleItems(items, { ...ALL, checkedOff: "only" }, "", held)), [1, 2, 3]);
-  assert.deepEqual(numbers(visibleItems(items, { ...ALL, hideDrafts: true }, "", held)), [1, 2]);
+  assert.deepEqual(numbers(visibleItems(ASSIGNED_RULES, items, ALL, "", held)), [1, 2, 3]);
+  assert.deepEqual(numbers(visibleItems(ASSIGNED_RULES, items, { ...ALL, checkedOff: "only" }, "", held)), [1, 2, 3]);
+  assert.deepEqual(numbers(visibleItems(ASSIGNED_RULES, items, { ...ALL, hideDrafts: true }, "", held)), [1, 2]);
 });
 
 test("the checked-off count is what the check-off filter alone hides", () => {
   const items = [item(1), item(2, { checkedOff: true }), item(3, { checkedOff: true, isDraft: true }), item(4, { checkedOff: true })];
 
-  assert.equal(hiddenCheckedOff(items, ALL, ""), 3);
-  assert.equal(hiddenCheckedOff(items, { ...ALL, hideDrafts: true }, ""), 2, "a draft the drafts filter hides anyway");
-  assert.equal(hiddenCheckedOff(items, ALL, "", new Set([items[1]!.url])), 2, "a held row is shown");
-  assert.equal(hiddenCheckedOff(items, { ...ALL, checkedOff: "show" }, ""), 0);
-  assert.equal(hiddenCheckedOff(items, { ...ALL, checkedOff: "only" }, ""), 0);
+  assert.equal(hiddenCheckedOff(ASSIGNED_RULES, items, ALL, ""), 3);
+  assert.equal(hiddenCheckedOff(ASSIGNED_RULES, items, { ...ALL, hideDrafts: true }, ""), 2, "a draft the drafts filter hides anyway");
+  assert.equal(hiddenCheckedOff(ASSIGNED_RULES, items, ALL, "", new Set([items[1]!.url])), 2, "a held row is shown");
+  assert.equal(hiddenCheckedOff(ASSIGNED_RULES, items, { ...ALL, checkedOff: "show" }, ""), 0);
+  assert.equal(hiddenCheckedOff(ASSIGNED_RULES, items, { ...ALL, checkedOff: "only" }, ""), 0);
 });
 
 test("the states label names whichever side is shorter", () => {
@@ -109,6 +123,12 @@ test("the states label names whichever side is shorter", () => {
   assert.equal(statesLabel(["requested", "commented", "changes-requested"]), "States: all but approved and approval reset");
 });
 
+test("Authored's states label names its review statuses the same way", () => {
+  assert.equal(statusesLabel(AUTHORED_DEFAULTS.states), "States: all but approved");
+  assert.equal(statusesLabel(["waiting", "approval-reset"]), "States: waiting and approval reset");
+  assert.equal(statusesLabel([...ReviewStatusSchema.options]), "States: all");
+});
+
 test("needs attention is what was never reviewed, asked again, unapproved or changed since the review", () => {
   assert.equal(needsAttention(item(1)), true);
   assert.equal(needsAttention(item(1, { state: "unapproved" })), true);
@@ -128,15 +148,131 @@ test("the attention count keeps what needs attention among what the default filt
     item(7, { forge: "gitlab", state: "requested", isDraft: true }),
   ];
 
-  assert.equal(attentionCount(items), 4);
-  assert.equal(attentionCount([]), 0);
+  assert.equal(attentionCount(inboxOf(items)), 4);
+  assert.equal(attentionCount(inboxOf([])), 0);
 });
 
 test("the search needs every word somewhere in the title, project, author or number as the forge writes it", () => {
   const mr = item(12, { forge: "gitlab", project: "example-group/service", title: "Add rate limiting", author: "kobe" });
 
-  for (const query of ["", "rate", "RATE limit", "service !12", "kobe", "  limiting  "]) assert.equal(matchesSearch(mr, query), true, query);
-  for (const query of ["#12", "rate github", "uploader"]) assert.equal(matchesSearch(mr, query), false, query);
+  for (const query of ["", "rate", "RATE limit", "service !12", "kobe", "  limiting  "]) assert.equal(matchesSearch(ASSIGNED_RULES, mr, query), true, query);
+  for (const query of ["#12", "rate github", "uploader"]) assert.equal(matchesSearch(ASSIGNED_RULES, mr, query), false, query);
+});
+
+function mine(number: number, overrides: Partial<AuthoredInboxItem> = {}): AuthoredInboxItem {
+  const { state: _, viaTeam: __, changedSinceReview: ___, ...listed } = item(number, { author: "me" });
+  return { ...listed, status: "waiting", reviewers: [], reviewedSinceLastPush: false, latestReviewAt: null, ...overrides };
+}
+
+const AUTHORED_DEFAULTS = DEFAULT_INBOX_PREFERENCES.authored;
+
+test("Authored lists newest first by default, drafts in their place, and filters by forge and drafts and sorts by its own preferences", () => {
+  const items = [
+    mine(1, { updatedAt: "2026-09-01T00:00:00Z", forge: "gitlab", additions: 1 }),
+    mine(2, { updatedAt: "2026-09-03T00:00:00Z", isDraft: true, additions: 50 }),
+    mine(3, { updatedAt: "2026-09-02T00:00:00Z", additions: 5 }),
+  ];
+
+  assert.deepEqual(numbers(visibleItems(AUTHORED_RULES, items, AUTHORED_DEFAULTS, "")), [2, 3, 1]);
+  assert.deepEqual(numbers(visibleItems(AUTHORED_RULES, items, { ...AUTHORED_DEFAULTS, provider: "github" }, "")), [2, 3]);
+  assert.deepEqual(numbers(visibleItems(AUTHORED_RULES, items, { ...AUTHORED_DEFAULTS, hideDrafts: true }, "")), [3, 1]);
+  assert.deepEqual(numbers(visibleItems(AUTHORED_RULES, items, { ...AUTHORED_DEFAULTS, sort: { key: "size", descending: false } }, "")), [1, 3, 2]);
+});
+
+test("Authored filters by review status, by default everything but what is approved", () => {
+  const items = [
+    mine(1, { status: "unreviewed" }),
+    mine(2, { status: "waiting" }),
+    mine(3, { status: "commented" }),
+    mine(4, { status: "changes-requested" }),
+    mine(5, { status: "approved" }),
+    mine(6, { status: "approval-reset" }),
+  ];
+
+  assert.deepEqual(numbers(visibleItems(AUTHORED_RULES, items, { ...AUTHORED_DEFAULTS, sort: { key: "created", descending: false } }, "")), [1, 2, 3, 4, 6]);
+  assert.deepEqual(numbers(visibleItems(AUTHORED_RULES, items, { ...AUTHORED_DEFAULTS, states: ["approved", "approval-reset"] }, "")), [5, 6]);
+});
+
+test("an authored change request needs attention on a change request, a review since the last push, or failing CI, and not on an approval reset", () => {
+  const items = [
+    mine(1, { status: "changes-requested" }),
+    mine(2, { status: "commented", reviewedSinceLastPush: true }),
+    mine(3, { status: "waiting", ci: "failure" }),
+    mine(4, { status: "approval-reset" }),
+    mine(5, { status: "commented", reviewedSinceLastPush: null, ci: "pending" }),
+    mine(6, { status: "approved", reviewedSinceLastPush: false, ci: "success" }),
+  ];
+  const attention = { ...AUTHORED_DEFAULTS, states: [...ReviewStatusSchema.options], needsAttention: true, sort: { key: "created" as const, descending: false } };
+
+  assert.deepEqual(numbers(visibleItems(AUTHORED_RULES, items, attention, "")), [1, 2, 3]);
+});
+
+test("Authored hides its checked-off change requests by default, shows them among the rest, or shows them alone", () => {
+  const items = [mine(1), mine(2, { checkedOff: true }), mine(3, { checkedOff: true, isDraft: true })];
+  const any = { ...AUTHORED_DEFAULTS, sort: { key: "created" as const, descending: false } };
+
+  assert.deepEqual(numbers(visibleItems(AUTHORED_RULES, items, any, "")), [1]);
+  assert.deepEqual(numbers(visibleItems(AUTHORED_RULES, items, { ...any, checkedOff: "show" }, "")), [1, 2, 3]);
+  assert.deepEqual(numbers(visibleItems(AUTHORED_RULES, items, { ...any, checkedOff: "only" }, "")), [2, 3]);
+  assert.deepEqual(numbers(visibleItems(AUTHORED_RULES, items, { ...any, checkedOff: "only" }, "", new Set([mine(1).url]))), [1, 2, 3], "a held row stays");
+  assert.equal(hiddenCheckedOff(AUTHORED_RULES, items, any, ""), 2);
+});
+
+test("checking a change request off marks it on that tab only, though the same one is on the other", () => {
+  const url = "https://gitlab.com/acme/uploader/-/merge_requests/7";
+  const both = inboxOf([item(7, { url }), item(8)], [mine(7, { url })]);
+
+  const assigned = withCheckedOff(both, "assigned", url, true);
+  assert.deepEqual([assigned.assigned.map((entry) => entry.checkedOff), assigned.authored.map((entry) => entry.checkedOff)], [[true, false], [false]]);
+  const authored = withCheckedOff(assigned, "authored", url, true);
+  assert.deepEqual([authored.assigned.map((entry) => entry.checkedOff), authored.authored.map((entry) => entry.checkedOff)], [[true, false], [true]]);
+  const unchecked = withCheckedOff(authored, "assigned", url, false);
+  assert.deepEqual([unchecked.assigned.map((entry) => entry.checkedOff), unchecked.authored.map((entry) => entry.checkedOff)], [[false, false], [true]]);
+});
+
+test("the search on Authored needs every word in the title, project, reviewers or number, not the viewer's own name", () => {
+  const mr = mine(12, {
+    forge: "gitlab",
+    project: "example-group/service",
+    title: "Add rate limiting",
+    reviewers: [
+      { name: "kobe", state: "approved" },
+      { name: "example-org/backend", state: "requested" },
+    ],
+  });
+
+  for (const query of ["", "rate", "service !12", "LIMITING", "kobe", "backend rate"]) assert.equal(matchesSearch(AUTHORED_RULES, mr, query), true, query);
+  for (const query of ["me", "#12", "uploader"]) assert.equal(matchesSearch(AUTHORED_RULES, mr, query), false, query);
+});
+
+function inboxOf(assigned: InboxItem[], authored: AuthoredInboxItem[] = [], hosts: Inbox["hosts"] = []): Inbox {
+  return { hosts, assigned, authored };
+}
+
+function host(name: string, truncated: Partial<Record<"assigned" | "authored", boolean>> = {}): Inbox["hosts"][number] {
+  return { forge: "github", host: name, truncated: { assigned: false, authored: false, ...truncated }, error: null };
+}
+
+test("a tab's label gives its listed total, with a + when a host listed only part of it, and no number until it is listed", () => {
+  const inbox = inboxOf([item(1), item(2, { checkedOff: true })], [mine(3)], [host("github.com", { authored: true }), host("gitlab.com")]);
+
+  assert.equal(tabLabel("assigned", undefined), "Assigned to me");
+  assert.equal(tabLabel("authored", undefined), "Authored by me");
+  assert.equal(tabLabel("assigned", inbox), "Assigned to me · 2");
+  assert.equal(tabLabel("authored", inbox), "Authored by me · 1+");
+  assert.equal(tabLabel("authored", inboxOf([], [])), "Authored by me · 0");
+});
+
+test("the sidebar's attention count leaves the viewer's own change requests out", () => {
+  const authored = [mine(1, { ci: "failure" }), mine(2)];
+
+  assert.equal(attentionCount(inboxOf([item(3)], authored)), 1);
+  assert.equal(attentionCount(inboxOf([], authored)), 0);
+});
+
+test("Authored counts change requests rather than reviews", () => {
+  assert.equal(countLabel(1, 1, 0, AUTHORED_RULES.noun), "1 change request");
+  assert.equal(countLabel(2, 5, 0, AUTHORED_RULES.noun), "2 of 5 change requests");
 });
 
 test("an age is the largest whole unit", () => {
diff --git a/plugins/guided-review/client/inbox-filter.ts b/plugins/guided-review/client/inbox-filter.ts
index 894b6d5..50b6258 100644
--- a/plugins/guided-review/client/inbox-filter.ts
+++ b/plugins/guided-review/client/inbox-filter.ts
@@ -1,7 +1,35 @@
-import { DEFAULT_INBOX_PREFERENCES, type InboxPreferences, type InboxSortKey } from "../shared/inbox-preferences.ts";
-import { ReviewerStateSchema, type InboxItem, type ReviewerState } from "../shared/inbox.ts";
+import { DEFAULT_INBOX_PREFERENCES, type AssignedPreferences, type InboxSortKey, type InboxTab } from "../shared/inbox-preferences.ts";
+import {
+  ReviewerStateSchema,
+  ReviewStatusSchema,
+  type AuthoredInboxItem,
+  type Inbox,
+  type InboxItem,
+  type ListedChangeRequest,
+  type ReviewerState,
+  type ReviewStatus,
+} from "../shared/inbox.ts";
 import { numberLabel } from "../shared/reference.ts";
 
+/** What every row of either tab has to be filtered by. */
+export type ListedItem = ListedChangeRequest & { checkedOff: boolean };
+
+/** What a tab's filters read of the preferences; the columns are the table's business. */
+export type ListFilters<State extends string> = Pick<AssignedPreferences, "provider" | "hideDrafts" | "checkedOff" | "needsAttention" | "sort"> & {
+  states: readonly State[];
+};
+
+/** How a tab reads its rows. */
+export type TabRules<Item extends ListedItem, State extends string> = {
+  /** Where a row stands, as the States filter reads it. */
+  state(item: Item): State;
+  needsAttention(item: Item): boolean;
+  /** What the search looks in, besides the number as the forge writes it. */
+  searched(item: Item): string[];
+  /** What a row is called, one and many. */
+  noun: readonly [string, string];
+};
+
 /**
  * Whether the reviewer has something to do on it: never reviewed, asked again, an approval the forge
  * took back, or the change moved on since their review.
@@ -10,14 +38,37 @@ export function needsAttention(item: InboxItem): boolean {
   return item.state === "requested" || item.state === "unapproved" || item.changedSinceReview === true;
 }
 
-/** Every word of `query` is in the title, the project, the author or the number as the forge writes it. */
-export function matchesSearch(item: InboxItem, query: string): boolean {
+export const ASSIGNED_RULES: TabRules<InboxItem, ReviewerState> = {
+  state: (item) => item.state,
+  needsAttention,
+  searched: (item) => [item.title, item.project, item.author],
+  noun: ["review", "reviews"],
+};
+
+/**
+ * Whether the author has something to do on their change request: changes asked for, a review since their last push, or failing CI.
+ * An approval reset waits on the reviewer, not the author.
+ */
+export function authoredNeedsAttention(item: AuthoredInboxItem): boolean {
+  return item.status === "changes-requested" || item.reviewedSinceLastPush === true || item.ci === "failure";
+}
+
+/** The author is always the viewer, so the search leaves their name out. */
+export const AUTHORED_RULES: TabRules<AuthoredInboxItem, ReviewStatus> = {
+  state: (item) => item.status,
+  needsAttention: authoredNeedsAttention,
+  searched: (item) => [item.title, item.project, ...item.reviewers.map((reviewer) => reviewer.name)],
+  noun: ["change request", "change requests"],
+};
+
+/** Every word of `query` is in what the tab searches or the number as the forge writes it. */
+export function matchesSearch<Item extends ListedItem>(rules: TabRules<Item, string>, item: Item, query: string): boolean {
   const words = query.toLowerCase().split(/\s+/).filter((word) => word !== "");
-  const text = [item.title, item.project, item.author, numberLabel(item.forge, item.number)].join(" ").toLowerCase();
+  const text = [...rules.searched(item), numberLabel(item.forge, item.number)].join(" ").toLowerCase();
   return words.every((word) => text.includes(word));
 }
 
-const SORT_VALUES: Record<InboxSortKey, (item: InboxItem) => number> = {
+const SORT_VALUES: Record<InboxSortKey, (item: ListedItem) => number> = {
   updated: (item) => Date.parse(item.updatedAt),
   created: (item) => Date.parse(item.createdAt),
   size: (item) => item.additions + item.deletions,
@@ -30,29 +81,42 @@ const NONE_HELD: ReadonlySet<string> = new Set();
  * The items the list shows, filtered as the preferences say and by the search, in their sort order; ties go to the latest update.
  * A `held` row is shown whether or not the check-off filter would take it, so a row just checked off or unchecked stays put.
  */
-export function visibleItems(items: readonly InboxItem[], preferences: InboxPreferences, query: string, held = NONE_HELD): InboxItem[] {
+export function visibleItems<Item extends ListedItem, State extends string>(
+  rules: TabRules<Item, State>,
+  items: readonly Item[],
+  preferences: ListFilters<State>,
+  query: string,
+  held = NONE_HELD,
+): Item[] {
   const value = SORT_VALUES[preferences.sort.key];
   const direction = preferences.sort.descending ? -1 : 1;
   return items
-    .filter((item) => matchesFilters(item, preferences, query) && (held.has(item.url) || passesCheckOff(item, preferences)))
+    .filter((item) => matchesFilters(rules, item, preferences, query) && (held.has(item.url) || passesCheckOff(item, preferences)))
     .sort((a, b) => direction * (value(a) - value(b)) || SORT_VALUES.updated(b) - SORT_VALUES.updated(a));
 }
 
 /** How many checked-off items the list leaves out that every other filter and the search would show. */
-export function hiddenCheckedOff(items: readonly InboxItem[], preferences: InboxPreferences, query: string, held = NONE_HELD): number {
-  return items.filter((item) => item.checkedOff && !held.has(item.url) && !passesCheckOff(item, preferences) && matchesFilters(item, preferences, query)).length;
+export function hiddenCheckedOff<Item extends ListedItem, State extends string>(
+  rules: TabRules<Item, State>,
+  items: readonly Item[],
+  preferences: ListFilters<State>,
+  query: string,
+  held = NONE_HELD,
+): number {
+  return items.filter((item) => item.checkedOff && !held.has(item.url) && !passesCheckOff(item, preferences) && matchesFilters(rules, item, preferences, query))
+    .length;
 }
 
-/** The list's default filters with only what needs the reviewer's attention kept, whatever the reviewer last set. */
-const ATTENTION_FILTERS: InboxPreferences = { ...DEFAULT_INBOX_PREFERENCES, needsAttention: true };
+/** The Assigned tab's default filters with only what needs the reviewer's attention kept, whatever the reviewer last set. */
+const ATTENTION_FILTERS: AssignedPreferences = { ...DEFAULT_INBOX_PREFERENCES.assigned, needsAttention: true };
 
-/** How many items need the reviewer's attention: the sidebar's count. */
-export function attentionCount(items: readonly InboxItem[]): number {
-  return items.filter((item) => matchesFilters(item, ATTENTION_FILTERS, "") && passesCheckOff(item, ATTENTION_FILTERS)).length;
+/** How many review requests need the reviewer's attention: the sidebar's count, which leaves their own change requests out. */
+export function attentionCount(inbox: Inbox): number {
+  return inbox.assigned.filter((item) => matchesFilters(ASSIGNED_RULES, item, ATTENTION_FILTERS, "") && passesCheckOff(item, ATTENTION_FILTERS)).length;
 }
 
 /** Whether the check-off filter shows the item, which a held row is not asked. */
-export function passesCheckOff(item: InboxItem, preferences: InboxPreferences): boolean {
+export function passesCheckOff(item: ListedItem, preferences: Pick<ListFilters<string>, "checkedOff">): boolean {
   switch (preferences.checkedOff) {
     case "hide":
       return !item.checkedOff;
@@ -63,16 +127,30 @@ export function passesCheckOff(item: InboxItem, preferences: InboxPreferences):
   }
 }
 
-function matchesFilters(item: InboxItem, preferences: InboxPreferences, query: string): boolean {
+function matchesFilters<Item extends ListedItem, State extends string>(rules: TabRules<Item, State>, item: Item, preferences: ListFilters<State>, query: string): boolean {
   return (
     (preferences.provider === "all" || item.forge === preferences.provider) &&
-    preferences.states.includes(item.state) &&
+    preferences.states.includes(rules.state(item)) &&
     (!preferences.hideDrafts || !item.isDraft) &&
-    (!preferences.needsAttention || needsAttention(item)) &&
-    matchesSearch(item, query)
+    (!preferences.needsAttention || rules.needsAttention(item)) &&
+    matchesSearch(rules, item, query)
   );
 }
 
+const TAB_TITLES: Record<InboxTab, string> = { assigned: "Assigned to me", authored: "Authored by me" };
+
+/** A tab's name with how many it lists, a `+` when a host listed only part of it, and no number until it is listed. */
+export function tabLabel(tab: InboxTab, inbox: Inbox | undefined): string {
+  if (inbox === undefined) return TAB_TITLES[tab];
+  const partial = inbox.hosts.some((host) => host.truncated[tab]);
+  return `${TAB_TITLES[tab]} · ${inbox[tab].length}${partial ? "+" : ""}`;
+}
+
+/** The inbox with the change request at `url` checked off or not on `tab`, leaving the same one on the other tab as it was. */
+export function withCheckedOff(inbox: Inbox, tab: InboxTab, url: string, checkedOff: boolean): Inbox {
+  return { ...inbox, [tab]: inbox[tab].map((item) => (item.url === url ? { ...item, checkedOff } : item)) };
+}
+
 /** Each reviewer state as a sentence names it mid-way. */
 export const STATE_NAMES: Record<ReviewerState, string> = {
   requested: "requested",
@@ -82,25 +160,40 @@ export const STATE_NAMES: Record<ReviewerState, string> = {
   unapproved: "approval reset",
 };
 
-/**
- * Which states the list shows, naming whichever side is shorter: `States: requested and commented`,
- * or `States: all but approved`.
- */
+/** Each review status of an authored change request as a sentence names it mid-way. */
+export const STATUS_NAMES: Record<ReviewStatus, string> = {
+  unreviewed: "unreviewed",
+  waiting: "waiting",
+  commented: "commented",
+  "changes-requested": "changes requested",
+  approved: "approved",
+  "approval-reset": "approval reset",
+};
+
+/** Which states the list shows, naming whichever side is shorter: `States: requested and commented`, or `States: all but approved`. */
 export function statesLabel(states: readonly ReviewerState[]): string {
-  const hidden = ReviewerStateSchema.options.filter((state) => !states.includes(state));
-  if (hidden.length === 0) return "States: all";
-  if (states.length <= hidden.length) return `States: ${namesOf(states)}`;
-  return `States: all but ${namesOf(hidden)}`;
+  return shownLabel(states, ReviewerStateSchema.options, STATE_NAMES);
 }
 
-function namesOf(states: readonly ReviewerState[]): string {
-  const names = states.map((state) => STATE_NAMES[state]);
-  return names.length === 1 ? names[0] : `${names.slice(0, -1).join(", ")} and ${names.at(-1)}`;
+/** Which review statuses the Authored tab shows, named as `statesLabel` names states. */
+export function statusesLabel(statuses: readonly ReviewStatus[]): string {
+  return shownLabel(statuses, ReviewStatusSchema.options, STATUS_NAMES);
+}
+
+function shownLabel<State extends string>(shown: readonly State[], all: readonly State[], names: Record<State, string>): string {
+  const hidden = all.filter((state) => !shown.includes(state));
+  if (hidden.length === 0) return "States: all";
+  const namesOf = (states: readonly State[]) => {
+    const named = states.map((state) => names[state]);
+    return named.length === 1 ? named[0] : `${named.slice(0, -1).join(", ")} and ${named.at(-1)}`;
+  };
+  if (shown.length <= hidden.length) return `States: ${namesOf(shown)}`;
+  return `States: all but ${namesOf(hidden)}`;
 }
 
-/** How many reviews the list shows, of how many when the filters or the search hide some, and how many of those are checked off. */
-export function countLabel(shown: number, total: number, checkedOff = 0): string {
-  const noun = total === 1 ? "review" : "reviews";
+/** How many rows the list shows, of how many when the filters or the search hide some, and how many of those are checked off. */
+export function countLabel(shown: number, total: number, checkedOff = 0, [one, many] = ASSIGNED_RULES.noun): string {
+  const noun = total === 1 ? one : many;
   const count = shown === total ? `${total} ${noun}` : `${shown} of ${total} ${noun}`;
   return checkedOff > 0 ? `${count} · ${checkedOff} checked off` : count;
 }
diff --git a/plugins/guided-review/client/inbox-preferences.ts b/plugins/guided-review/client/inbox-preferences.ts
index d6b9dd3..50155cf 100644
--- a/plugins/guided-review/client/inbox-preferences.ts
+++ b/plugins/guided-review/client/inbox-preferences.ts
@@ -2,11 +2,11 @@ import { useRpc } from "@getpaseo/plugin/client";
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import * as contracts from "../shared/contracts.ts";
 import { PLUGIN_ID } from "../shared/identity.ts";
-import { DEFAULT_INBOX_PREFERENCES, type InboxPreferences } from "../shared/inbox-preferences.ts";
+import { DEFAULT_INBOX_PREFERENCES, type InboxPreferences, type InboxTab } from "../shared/inbox-preferences.ts";
 
-export type InboxPreferencesControl = {
-  preferences: InboxPreferences;
-  change(update: Partial<InboxPreferences>): void;
+export type InboxPreferencesControl<Preferences> = {
+  preferences: Preferences;
+  change(update: Partial<Preferences>): void;
   /** Why the latest change could not be kept, as a sentence. */
   error: string | null;
 };
@@ -14,11 +14,10 @@ export type InboxPreferencesControl = {
 const QUERY_KEY = [PLUGIN_ID, "inbox-preferences"];
 
 /**
- * The review list's filters, sort and columns as the daemon keeps them. A change shows at once and
- * is saved whole behind it; the answer is not read back, since a slower answer to an earlier save
- * would undo a later change.
+ * One tab's filters, sort and columns as the daemon keeps them.
+ * A change shows at once and is saved behind it, with the other tab's, whole; the answer is not read back, since a slower answer to an earlier save would undo a later change.
  */
-export function useInboxPreferences(): InboxPreferencesControl {
+export function useInboxPreferences<Tab extends InboxTab>(tab: Tab): InboxPreferencesControl<InboxPreferences[Tab]> {
   const getPreferences = useRpc(contracts.getInboxPreferences);
   const savePreferences = useRpc(contracts.saveInboxPreferences);
   const queryClient = useQueryClient();
@@ -26,9 +25,10 @@ export function useInboxPreferences(): InboxPreferencesControl {
   const save = useMutation({ mutationFn: savePreferences });
 
   return {
-    preferences: stored.data ?? DEFAULT_INBOX_PREFERENCES,
+    preferences: (stored.data ?? DEFAULT_INBOX_PREFERENCES)[tab],
     change(update) {
-      const next = { ...(queryClient.getQueryData<InboxPreferences>(QUERY_KEY) ?? DEFAULT_INBOX_PREFERENCES), ...update };
+      const current = queryClient.getQueryData<InboxPreferences>(QUERY_KEY) ?? DEFAULT_INBOX_PREFERENCES;
+      const next: InboxPreferences = { ...current, [tab]: { ...current[tab], ...update } };
       queryClient.setQueryData(QUERY_KEY, next);
       save.mutate(next);
     },
diff --git a/plugins/guided-review/client/inbox.tsx b/plugins/guided-review/client/inbox.tsx
index d523333..fdea1ec 100644
--- a/plugins/guided-review/client/inbox.tsx
+++ b/plugins/guided-review/client/inbox.tsx
@@ -1,17 +1,53 @@
 import { useRpc } from "@getpaseo/plugin/client";
 import { Modal, TextInput } from "@getpaseo/plugin/client/react-native";
 import { ExternalLink, SettingsAction, SettingsCard, SettingsSection, SettingsSwitch } from "@getpaseo/plugin/client/ui";
-import { useQuery } from "@tanstack/react-query";
+import { useQuery, type UseQueryResult } from "@tanstack/react-query";
 import React, { useContext, useState } from "react";
 import { Pressable, Text, View } from "react-native";
 import * as contracts from "../shared/contracts.ts";
-import { CHECK_OFF_FILTERS, INBOX_COLUMNS, type CheckOffFilter, type InboxColumn, type InboxPreferences, type InboxSortKey } from "../shared/inbox-preferences.ts";
-import { headMoved, ReviewerStateSchema, type Inbox, type InboxItem, type LocalReview, type ReviewerState } from "../shared/inbox.ts";
+import {
+  ASSIGNED_COLUMNS,
+  AUTHORED_COLUMNS,
+  CHECK_OFF_FILTERS,
+  INBOX_TABS,
+  type AssignedColumn,
+  type AuthoredColumn,
+  type CheckOffFilter,
+  type InboxSortKey,
+  type InboxTab,
+} from "../shared/inbox-preferences.ts";
+import {
+  headMoved,
+  ReviewerStateSchema,
+  ReviewStatusSchema,
+  type AuthoredInboxItem,
+  type Inbox,
+  type InboxItem,
+  type LocalReview,
+  type ReviewerState,
+  type ReviewStatus,
+} from "../shared/inbox.ts";
 import { numberLabel } from "../shared/reference.ts";
 import { Button } from "./button.tsx";
-import { CheckOffContext, INBOX_QUERY_KEY, useCheckOff } from "./check-off.ts";
-import { age, countLabel, hiddenCheckedOff, passesCheckOff, STATE_NAMES, statesLabel, visibleItems } from "./inbox-filter.ts";
-import { useInboxPreferences } from "./inbox-preferences.ts";
+import { ASSIGNED_CHECK_OFF, AUTHORED_CHECK_OFF, CheckOffContext, INBOX_QUERY_KEY, useCheckOff, type CheckOffControl } from "./check-off.ts";
+import {
+  age,
+  ASSIGNED_RULES,
+  AUTHORED_RULES,
+  countLabel,
+  hiddenCheckedOff,
+  passesCheckOff,
+  STATE_NAMES,
+  STATUS_NAMES,
+  statesLabel,
+  statusesLabel,
+  tabLabel,
+  visibleItems,
+  type ListedItem,
+  type ListFilters,
+  type TabRules,
+} from "./inbox-filter.ts";
+import { useInboxPreferences, type InboxPreferencesControl } from "./inbox-preferences.ts";
 import { NewReview } from "./new-review.tsx";
 import { describePreparing, describeProgress } from "./start-progress.ts";
 import { useReviewStarts, type Pasted, type ReviewStarts } from "./start-review.ts";
@@ -22,73 +58,212 @@ const FORGE_NAMES = { github: "GitHub", gitlab: "GitLab" } as const;
 
 const CHECK_OFF_LABELS: Record<CheckOffFilter, string> = { hide: "Hide checked off", show: "With checked off", only: "Checked off only" };
 
-/** The open change requests the reviewer reviews, to pick one and start or continue its review. */
+/** A row of either tab, with the review started here if any. */
+type Row = ListedItem & { reviewId: string | null; local: LocalReview | null };
+
+/** One tab's filters, sort and columns. */
+type TabPreferences<State extends string, Column extends string> = ListFilters<State> & { columns: Column[] };
+
+/** The States chooser of a tab that has states to filter by. */
+type StatesSetup<State extends string> = {
+  all: readonly State[];
+  label(states: readonly State[]): string;
+  name(state: State): string;
+  hint(state: State): string | undefined;
+};
+
+/** What a tab shows and offers, beside how its filters read a row. */
+type TabView<Item extends Row, State extends string, Column extends string> = {
+  tab: InboxTab;
+  rules: TabRules<Item, State>;
+  /** Every column the tab can have, in the order it shows them. */
+  columns: readonly Column[];
+  specs: Record<Column, ColumnSpec<Item>>;
+  /** The columns a card puts on its tinted line, in the order it puts them. */
+  tinted: readonly Column[];
+  states: StatesSetup<State>;
+  searchHint: string;
+  listing: string;
+  failure: string;
+  empty: string;
+};
+
+/** The change requests the viewer reviews and the ones they authored, as two tabs, to pick one and start or continue its review. */
 export function ReviewInbox({ colors, compact, openPanel }: { colors: Colors; compact: boolean; openPanel: (workspaceId: string) => void }) {
   const getInbox = useRpc(contracts.getInbox);
   const inbox = useQuery({ queryKey: INBOX_QUERY_KEY, queryFn: () => getInbox({}), refetchOnWindowFocus: false });
-  const starts = useReviewStarts(openPanel, inbox.data?.items ?? []);
-  const { preferences, change: changePreferences, error } = useInboxPreferences();
-  const checkOff = useCheckOff();
-  const [query, setSearch] = useState("");
+  const starts = useReviewStarts(openPanel, [...(inbox.data?.assigned ?? []), ...(inbox.data?.authored ?? [])]);
+  const assigned = useInboxPreferences("assigned");
+  const authored = useInboxPreferences("authored");
+  const checkOffs = { assigned: useCheckOff(ASSIGNED_CHECK_OFF), authored: useCheckOff(AUTHORED_CHECK_OFF) };
+  const [tab, setTab] = useState<InboxTab>("assigned");
+  const [queries, setQueries] = useState<Record<InboxTab, string>>({ assigned: "", authored: "" });
   const [width, setWidth] = useState<number | null>(null);
-  const [choosing, setChoosing] = useState<"columns" | "states" | null>(null);
 
-  const change = (update: Partial<InboxPreferences>) => {
-    checkOff.release();
-    changePreferences(update);
-  };
   const setQuery = (next: string) => {
-    checkOff.release();
-    setSearch(next);
+    checkOffs[tab].release();
+    setQueries((current) => ({ ...current, [tab]: next }));
   };
   const refresh = () => {
-    checkOff.release();
+    checkOffs.assigned.release();
+    checkOffs.authored.release();
     starts.forget();
     void inbox.refetch();
   };
-  const items = (inbox.data ? visibleItems(inbox.data.items, preferences, query, checkOff.held) : []).map((item) => ({
-    ...item,
-    local: starts.local(item.reviewId, item.local),
-  }));
-  // Until the list has been measured it is not drawn, rather than as cards for a frame.
-  const shape = compact ? "cards" : width === null ? null : width >= tableWidth(preferences.columns) ? "table" : "cards";
-  const rows = { toggle: checkOff.toggle, dimmed: (item: InboxItem) => checkOff.held.has(item.url) && !passesCheckOff(item, preferences) };
+  const shared = {
+    colors,
+    compact,
+    width,
+    inbox,
+    starts,
+    refresh,
+    query: queries[tab],
+    setQuery,
+    tabs: <TabSwitch colors={colors} tab={tab} setTab={setTab} inbox={inbox.data} />,
+  };
 
   return (
     <View onLayout={onVisibleWidth(setWidth)}>
+      {tab === "assigned" ? (
+        <TabSection key={tab} {...shared} view={ASSIGNED_VIEW} listed={inbox.data?.assigned} preferences={assigned} checkOff={checkOffs.assigned} />
+      ) : (
+        <TabSection key={tab} {...shared} view={AUTHORED_VIEW} listed={inbox.data?.authored} preferences={authored} checkOff={checkOffs.authored} />
+      )}
+    </View>
+  );
+}
+
+/** The two tabs as one switch, each with how many it lists. */
+function TabSwitch({ colors, tab, setTab, inbox }: { colors: Colors; tab: InboxTab; setTab: (tab: InboxTab) => void; inbox: Inbox | undefined }) {
+  return (
+    <View
+      accessibilityRole="tablist"
+      style={{ flexDirection: "row", alignSelf: "flex-start", borderWidth: 1, borderColor: colors.border, borderRadius: radius.md, overflow: "hidden" }}
+    >
+      {INBOX_TABS.map((candidate) => {
+        const selected = candidate === tab;
+        return (
+          <Pressable
+            key={candidate}
+            onPress={() => setTab(candidate)}
+            accessibilityRole="tab"
+            accessibilityState={{ selected }}
+            style={({ pressed }) => ({
+              paddingVertical: spacing[1],
+              paddingHorizontal: spacing[3],
+              backgroundColor: selected ? colors.accent : undefined,
+              opacity: pressed ? 0.85 : 1,
+            })}
+          >
+            <Text
+              style={{
+                color: selected ? colors.accentForeground : colors.foreground,
+                fontSize: fontSize.sm,
+                lineHeight: leading(fontSize.sm),
+                fontVariant: ["tabular-nums"],
+              }}
+            >
+              {tabLabel(candidate, inbox)}
+            </Text>
+          </Pressable>
+        );
+      })}
+    </View>
+  );
+}
+
+/** The section as one tab shows it. */
+function TabSection<Item extends Row, State extends string, Column extends string>({
+  colors,
+  compact,
+  width,
+  inbox,
+  starts,
+  refresh,
+  query,
+  setQuery,
+  tabs,
+  view,
+  listed = [],
+  preferences: control,
+  checkOff,
+}: {
+  colors: Colors;
+  compact: boolean;
+  width: number | null;
+  inbox: UseQueryResult<Inbox>;
+  starts: ReviewStarts;
+  refresh: () => void;
+  query: string;
+  setQuery: (query: string) => void;
+  tabs: React.ReactNode;
+  view: TabView<Item, State, Column>;
+  listed: readonly Item[] | undefined;
+  preferences: InboxPreferencesControl<TabPreferences<State, Column>>;
+  checkOff: CheckOffControl<Item>;
+}) {
+  const { preferences, error } = control;
+  const [choosing, setChoosing] = useState<"columns" | "states" | null>(null);
+  const { held } = checkOff;
+
+  const change = (update: Partial<TabPreferences<State, Column>>) => {
+    checkOff.release();
+    control.change(update);
+  };
+  const items = visibleItems(view.rules, listed, preferences, query, held).map((item) => ({ ...item, local: starts.local(item.reviewId, item.local) }));
+  // Until the list has been measured it is not drawn, rather than as cards for a frame.
+  const shape = compact ? "cards" : width === null ? null : width >= tableWidth(view.specs, preferences.columns) ? "table" : "cards";
+  const rows = {
+    toggle: (row: ListedItem) => {
+      const item = listed.find((entry) => entry.url === row.url);
+      if (item !== undefined) checkOff.toggle(item);
+    },
+    dimmed: (item: ListedItem) => held.has(item.url) && !passesCheckOff(item, preferences),
+  };
+
+  return (
+    <>
       <SettingsSection
-        title="Assigned to me for review"
+        title="Change requests"
         trailing={
           <View style={{ flexDirection: "row", gap: spacing[2] }}>
             <NewReview colors={colors} starts={starts} />
             <Button colors={colors} small label="Columns" onPress={() => setChoosing("columns")} />
-            <Button colors={colors} small label={statesLabel(preferences.states)} onPress={() => setChoosing("states")} />
+            <Button colors={colors} small label={view.states.label(preferences.states)} onPress={() => setChoosing("states")} />
             <Button colors={colors} small label={inbox.isFetching ? "Refreshing…" : "Refresh"} disabled={inbox.isFetching || checkOff.saving} onPress={refresh} />
           </View>
         }
       >
         <View style={{ gap: spacing[3] }}>
-          <Toolbar colors={colors} preferences={preferences} change={change} query={query} setQuery={setQuery} />
+          {tabs}
+          <Toolbar
+            colors={colors}
+            preferences={preferences}
+            change={change}
+            query={query}
+            setQuery={setQuery}
+            searchHint={view.searchHint}
+          />
           {error !== null ? <Note colors={colors} tone="danger" text={`Could not keep these filters for next time: ${error}`} /> : null}
           {checkOff.error !== null ? <Note colors={colors} tone="danger" text={`Could not keep that check-off: ${checkOff.error}`} /> : null}
-          {inbox.data ? <HostNotes colors={colors} hosts={inbox.data.hosts} /> : null}
+          {inbox.data ? <HostNotes colors={colors} hosts={inbox.data.hosts} tab={view.tab} /> : null}
           <PastedRows colors={colors} starts={starts} shown={items} />
           {inbox.isPending ? (
-            <Note colors={colors} text="Listing what you are asked to review…" />
+            <Note colors={colors} text={view.listing} />
           ) : inbox.isError ? (
-            <Note colors={colors} tone="danger" text={`Could not list your reviews: ${inbox.error.message}`} />
+            <Note colors={colors} tone="danger" text={`${view.failure}: ${inbox.error.message}`} />
           ) : items.length === 0 ? (
-            <Note colors={colors} text={inbox.data.items.length === 0 ? "Nothing to review." : "Nothing matches these filters."} />
+            <Note colors={colors} text={listed.length === 0 ? view.empty : "Nothing matches these filters."} />
           ) : (
             <CheckOffContext.Provider value={rows}>
               <View style={{ gap: spacing[2] }}>
-                <Note colors={colors} text={countLabel(items.length, inbox.data.items.length, hiddenCheckedOff(inbox.data.items, preferences, query, checkOff.held))} />
+                <Note colors={colors} text={countLabel(items.length, listed.length, hiddenCheckedOff(view.rules, listed, preferences, query, held), view.rules.noun)} />
                 {shape === "table" ? (
-                  <Table colors={colors} items={items} preferences={preferences} change={change} starts={starts} />
+                  <Table colors={colors} items={items} specs={view.specs} columns={preferences.columns} preferences={preferences} change={change} starts={starts} />
                 ) : shape === "cards" ? (
                   <View style={{ gap: spacing[2] }}>
                     {items.map((item) => (
-                      <Card key={item.url} colors={colors} item={item} columns={preferences.columns} starts={starts} />
+                      <Card key={item.url} colors={colors} item={item} specs={view.specs} columns={preferences.columns} tinted={view.tinted} starts={starts} />
                     ))}
                   </View>
                 ) : null}
@@ -97,109 +272,120 @@ export function ReviewInbox({ colors, compact, openPanel }: { colors: Colors; co
           )}
         </View>
       </SettingsSection>
-      <ColumnChooser open={choosing === "columns"} onOpenChange={(open) => setChoosing(open ? "columns" : null)} columns={preferences.columns} change={change} />
-      <StateChooser open={choosing === "states"} onOpenChange={(open) => setChoosing(open ? "states" : null)} states={preferences.states} change={change} />
-    </View>
+      <ColumnChooser
+        open={choosing === "columns"}
+        onOpenChange={(open) => setChoosing(open ? "columns" : null)}
+        all={view.columns}
+        specs={view.specs}
+        columns={preferences.columns}
+        change={change}
+      />
+      <StateChooser open={choosing === "states"} onOpenChange={(open) => setChoosing(open ? "states" : null)} setup={view.states} states={preferences.states} change={change} />
+    </>
   );
 }
 
-const COLUMN_HINTS: Partial<Record<InboxColumn, string>> = {
-  checked: "Set a review aside here until it is pushed to or you are asked again",
-  title: "Always shown",
-  state: "Where you stand, and whether it changed since your review",
-  local: "The guide and drafts you have for it in this plugin",
-  ci: "Whether the head's pipeline or checks passed",
-};
-
 /** Which columns the table shows; the title is what a row is, so it always is. */
-function ColumnChooser({
+function ColumnChooser<Item extends Row, Column extends string>({
   open,
   onOpenChange,
+  all,
+  specs,
   columns,
   change,
 }: {
   open: boolean;
   onOpenChange: (open: boolean) => void;
-  columns: readonly InboxColumn[];
-  change: (update: Partial<InboxPreferences>) => void;
+  all: readonly Column[];
+  specs: Record<Column, ColumnSpec<Item>>;
+  columns: readonly Column[];
+  change: (update: { columns: Column[] }) => void;
 }) {
-  const toggle = (column: InboxColumn, shown: boolean) =>
-    change({ columns: INBOX_COLUMNS.filter((candidate) => (candidate === column ? shown : columns.includes(candidate))) });
+  const toggle = (column: Column, shown: boolean) => change({ columns: all.filter((candidate) => (candidate === column ? shown : columns.includes(candidate))) });
   return (
     <Modal title="Columns" open={open} onOpenChange={onOpenChange}>
       <Modal.Content>
         <SettingsCard>
-          {INBOX_COLUMNS.map((column) => (
-            <SettingsSwitch
-              key={column}
-              label={COLUMNS[column].label}
-              {...(COLUMN_HINTS[column] === undefined ? {} : { hint: COLUMN_HINTS[column] })}
-              value={column === "title" || columns.includes(column)}
-              disabled={column === "title"}
-              onValueChange={(shown) => toggle(column, shown)}
-            />
-          ))}
+          {all.map((column) => {
+            const { label, hint } = specs[column];
+            return (
+              <SettingsSwitch
+                key={column}
+                label={label}
+                {...(hint === undefined ? {} : { hint })}
+                value={column === "title" || columns.includes(column)}
+                disabled={column === "title"}
+                onValueChange={(shown) => toggle(column, shown)}
+              />
+            );
+          })}
         </SettingsCard>
       </Modal.Content>
     </Modal>
   );
 }
 
-/** Which reviewer states the list shows; the last one shown stays on, as a list showing none is no use. */
-function StateChooser({
+/** Which states the list shows; the last one shown stays on, as a list showing none is no use. */
+function StateChooser<State extends string>({
   open,
   onOpenChange,
+  setup,
   states,
   change,
 }: {
   open: boolean;
   onOpenChange: (open: boolean) => void;
-  states: readonly ReviewerState[];
-  change: (update: Partial<InboxPreferences>) => void;
+  setup: StatesSetup<State>;
+  states: readonly State[];
+  change: (update: { states: State[] }) => void;
 }) {
-  const all = ReviewerStateSchema.options;
-  const toggle = (state: ReviewerState, shown: boolean) =>
-    change({ states: all.filter((candidate) => (candidate === state ? shown : states.includes(candidate))) });
+  const { all } = setup;
+  const toggle = (state: State, shown: boolean) => change({ states: all.filter((candidate) => (candidate === state ? shown : states.includes(candidate))) });
   return (
     <Modal title="States" open={open} onOpenChange={onOpenChange}>
       <Modal.Content>
         <SettingsCard>
           <SettingsAction label="All" actionLabel="Show all" disabled={states.length === all.length} onPress={() => change({ states: [...all] })} />
-          {all.map((state) => (
-            <SettingsSwitch
-              key={state}
-              label={STATE_NAMES[state].charAt(0).toUpperCase() + STATE_NAMES[state].slice(1)}
-              {...(state === "unapproved" ? { hint: "GitLab only" } : {})}
-              value={states.includes(state)}
-              disabled={states.length === 1 && states.includes(state)}
-              onValueChange={(shown) => toggle(state, shown)}
-            />
-          ))}
+          {all.map((state) => {
+            const hint = setup.hint(state);
+            return (
+              <SettingsSwitch
+                key={state}
+                label={setup.name(state)}
+                {...(hint === undefined ? {} : { hint })}
+                value={states.includes(state)}
+                disabled={states.length === 1 && states.includes(state)}
+                onValueChange={(shown) => toggle(state, shown)}
+              />
+            );
+          })}
         </SettingsCard>
       </Modal.Content>
     </Modal>
   );
 }
 
-function Toolbar({
+function Toolbar<State extends string>({
   colors,
   preferences,
   change,
   query,
   setQuery,
+  searchHint,
 }: {
   colors: Colors;
-  preferences: InboxPreferences;
-  change: (update: Partial<InboxPreferences>) => void;
+  preferences: ListFilters<State>;
+  change: (update: Partial<ListFilters<State>>) => void;
   query: string;
   setQuery: (query: string) => void;
+  searchHint: string;
 }) {
   return (
     <View style={{ gap: spacing[2] }}>
       <TextInput
         value={query}
         onChangeText={setQuery}
-        placeholder="Search by title, project, author or number"
+        placeholder={searchHint}
         placeholderTextColor={colors.foregroundMuted}
         autoCorrect={false}
         autoCapitalize="none"
@@ -225,10 +411,10 @@ function Toolbar({
             onPress={() => change({ provider })}
           />
         ))}
-        <View style={{ width: 1, alignSelf: "stretch", backgroundColor: colors.border, marginHorizontal: spacing[1] }} />
+        <Divider colors={colors} />
         <Chip colors={colors} label="Needs my attention" selected={preferences.needsAttention} onPress={() => change({ needsAttention: !preferences.needsAttention })} />
         <Chip colors={colors} label="Hide drafts" selected={preferences.hideDrafts} onPress={() => change({ hideDrafts: !preferences.hideDrafts })} />
-        <View style={{ width: 1, alignSelf: "stretch", backgroundColor: colors.border, marginHorizontal: spacing[1] }} />
+        <Divider colors={colors} />
         {CHECK_OFF_FILTERS.map((checkedOff) => (
           <Chip
             key={checkedOff}
@@ -243,6 +429,10 @@ function Toolbar({
   );
 }
 
+function Divider({ colors }: { colors: Colors }) {
+  return <View style={{ width: 1, alignSelf: "stretch", backgroundColor: colors.border, marginHorizontal: spacing[1] }} />;
+}
+
 function Chip({ colors, label, selected, onPress }: { colors: Colors; label: string; selected: boolean; onPress: () => void }) {
   return (
     <Pressable
@@ -272,11 +462,11 @@ function Note({ colors, text, tone }: { colors: Colors; text: string; tone?: "da
   );
 }
 
-/** A host that could not be listed, or has more than one page, says so; the rest list as usual. */
-function HostNotes({ colors, hosts }: { colors: Colors; hosts: Inbox["hosts"] }) {
+/** A host that could not be listed says so on both tabs, and one with more than a page says so on the tab it cut short; the rest list as usual. */
+function HostNotes({ colors, hosts, tab }: { colors: Colors; hosts: Inbox["hosts"]; tab: InboxTab }) {
   const notes = hosts.flatMap((host): { key: string; tone?: "danger"; text: string }[] => {
     if (host.error !== null) return [{ key: host.host, tone: "danger", text: `${host.host}: ${host.error}` }];
-    if (host.truncated) return [{ key: host.host, text: `${host.host} has more than this lists; only the first page is shown.` }];
+    if (host.truncated[tab]) return [{ key: host.host, text: `${host.host} has more than this lists; only the first page is shown.` }];
     return [];
   });
   if (notes.length === 0) return null;
@@ -291,6 +481,10 @@ function HostNotes({ colors, hosts }: { colors: Colors; hosts: Inbox["hosts"] })
 
 type Tinted = { text: string; color: keyof Colors };
 
+function capitalised(text: string): string {
+  return text.charAt(0).toUpperCase() + text.slice(1);
+}
+
 /** Where the reviewer stands, with whether it moved on since their review. */
 function stateOf(item: InboxItem): Tinted {
   const since = item.changedSinceReview === true;
@@ -309,6 +503,58 @@ function stateOf(item: InboxItem): Tinted {
   }
 }
 
+const STATUS_TINTS: Record<ReviewStatus, keyof Colors> = {
+  unreviewed: "foregroundMuted",
+  waiting: "foreground",
+  commented: "foregroundMuted",
+  "changes-requested": "statusDanger",
+  approved: "statusSuccess",
+  "approval-reset": "statusWarning",
+};
+
+const STATUS_HINTS: Record<ReviewStatus, string> = {
+  unreviewed: "Nobody is asked and nobody reviewed",
+  waiting: "Reviewers are asked and none reviewed yet",
+  commented: "Reviews without an approval or a change request",
+  "changes-requested": "A reviewer's latest review asks for changes",
+  approved: "Approved, with no change request outstanding",
+  "approval-reset": "An approval taken back by a push, or on GitLab by its reviewer",
+};
+
+/** Where the author's reviewers stand, with whether one reviewed since their last push. */
+function statusOf(item: AuthoredInboxItem): Tinted {
+  const text = capitalised(STATUS_NAMES[item.status]);
+  if (item.reviewedSinceLastPush === true) return { text: `${text} · reviewed since your last push`, color: "statusWarning" };
+  return { text, color: STATUS_TINTS[item.status] };
+}
+
+const REVIEWER_TINTS: Record<ReviewerState, keyof Colors> = {
+  requested: "foreground",
+  commented: "foregroundMuted",
+  "changes-requested": "statusDanger",
+  approved: "statusSuccess",
+  unapproved: "statusWarning",
+};
+
+function reviewersOf(item: AuthoredInboxItem): Tinted[] {
+  return item.reviewers.map((reviewer) => ({ text: reviewer.name, color: REVIEWER_TINTS[reviewer.state] }));
+}
+
+/** Each reviewer in their own tint, as many as fit on two lines. */
+function ReviewersCell({ colors, reviewers }: { colors: Colors; reviewers: Tinted[] }) {
+  if (reviewers.length === 0) return <Cell colors={colors} text="—" color="foregroundMuted" />;
+  return (
+    <Text numberOfLines={2} style={{ color: colors.foregroundMuted, fontSize: fontSize.sm, lineHeight: leading(fontSize.sm) }}>
+      {reviewers.map((reviewer, index) => (
+        <React.Fragment key={reviewer.text}>
+          {index > 0 ? ", " : ""}
+          <Text style={{ color: colors[reviewer.color] }}>{reviewer.text}</Text>
+        </React.Fragment>
+      ))}
+    </Text>
+  );
+}
+
 const GUIDE_STATES: Record<LocalReview["guide"], string> = {
   none: "Started",
   "choosing-scope": "Choose what to guide",
@@ -317,8 +563,8 @@ const GUIDE_STATES: Record<LocalReview["guide"], string> = {
   failed: "Guide failed",
 };
 
-/** What this plugin has of the review, and the reviewer's pending drafts wherever they were written. */
-function localOf(item: InboxItem): Tinted | null {
+/** What this plugin has of the review, and the viewer's pending drafts wherever they were written. */
+function localOf(item: Row): Tinted | null {
   const drafts = item.pendingDrafts ? [`${item.pendingDrafts} draft${item.pendingDrafts === 1 ? "" : "s"}`] : [];
   const { local } = item;
   if (local === null) return drafts.length > 0 ? { text: drafts.join(" · "), color: "foregroundMuted" } : null;
@@ -331,7 +577,7 @@ function localOf(item: InboxItem): Tinted | null {
   return { text: parts.join(" · "), color };
 }
 
-function ciOf(item: InboxItem): Tinted | null {
+function ciOf(item: Row): Tinted | null {
   switch (item.ci) {
     case "success":
       return { text: "Passed", color: "statusSuccess" };
@@ -344,50 +590,139 @@ function ciOf(item: InboxItem): Tinted | null {
   }
 }
 
-function linesOf(item: InboxItem): string {
+function linesOf(item: Row): string {
   return `+${item.additions} −${item.deletions}`;
 }
 
-function filesOf(item: InboxItem): string {
+function filesOf(item: Row): string {
   return `${item.fileCount} file${item.fileCount === 1 ? "" : "s"}`;
 }
 
 /** A column's width: fixed for a value whose length is known, else a share of what is left, never under `min`. */
 type ColumnWidth = { width: number } | { flex: number; min: number };
 
-/** `label` names the column in the chooser, and heads it unless `header` says otherwise. */
-type ColumnSpec = { label: string; header?: string; size: ColumnWidth; sort?: InboxSortKey; cell: (item: InboxItem, colors: Colors, now: Date) => React.ReactNode };
+/**
+ * `label` names the column in the chooser, and heads it unless `header` says otherwise.
+ * A card puts the `besideTitle` column before the title, every `line` on the line under it, and every `tint` on the tinted line below that, in the tab's `tinted` order.
+ */
+type ColumnSpec<Item> = {
+  label: string;
+  header?: string;
+  hint?: string;
+  size: ColumnWidth;
+  sort?: InboxSortKey;
+  cell: (item: Item, colors: Colors, now: Date) => React.ReactNode;
+  line?: (item: Item, now: Date) => string;
+  tint?: (item: Item) => Tinted | Tinted[] | null;
+  besideTitle?: true;
+};
+
+function tintedColumn<Item>(spec: Omit<ColumnSpec<Item>, "cell" | "tint">, tint: (item: Item) => Tinted | null): ColumnSpec<Item> {
+  return { ...spec, tint, cell: (item, colors) => <TintedCell colors={colors} value={tint(item)} /> };
+}
 
-const COLUMNS: Record<InboxColumn, ColumnSpec> = {
-  checked: { label: "Checked off", header: "", size: { width: 20 }, cell: (item, colors) => <CheckOffBox colors={colors} item={item} /> },
+function textColumn<Item>(spec: Omit<ColumnSpec<Item>, "cell" | "line">, text: (item: Item, now: Date) => string, line: (item: Item, now: Date) => string): ColumnSpec<Item> {
+  return { ...spec, line, cell: (item, colors, now) => <Cell colors={colors} text={text(item, now)} color="foregroundMuted" /> };
+}
+
+/** The columns both tabs fill the same way. */
+const ROW_COLUMNS = {
   change: {
     label: "PR/MR",
     size: { flex: 1.2, min: 96 },
-    cell: (item, colors) => (
+    line: (item: Row) => item.project,
+    cell: (item: Row, colors: Colors) => (
       <View>
         <NumberLink colors={colors} item={item} />
         <Cell colors={colors} text={item.project} color="foregroundMuted" />
       </View>
     ),
   },
-  title: { label: "Title", size: { flex: 3, min: 160 }, cell: (item, colors) => <Title colors={colors} item={item} /> },
-  author: { label: "Author", size: { flex: 1, min: 64 }, cell: (item, colors) => <Cell colors={colors} text={item.author} color="foregroundMuted" /> },
-  updated: { label: "Updated", size: { width: 72 }, sort: "updated", cell: (item, colors, now) => <Cell colors={colors} text={age(item.updatedAt, now)} color="foregroundMuted" /> },
-  created: { label: "Created", size: { width: 72 }, sort: "created", cell: (item, colors, now) => <Cell colors={colors} text={age(item.createdAt, now)} color="foregroundMuted" /> },
+  title: { label: "Title", hint: "Always shown", size: { flex: 3, min: 160 }, cell: (item: Row, colors: Colors) => <Title colors={colors} item={item} /> },
+  updated: textColumn<Row>(
+    { label: "Updated", size: { width: 72 }, sort: "updated" },
+    (item, now) => age(item.updatedAt, now),
+    (item, now) => `updated ${age(item.updatedAt, now)} ago`,
+  ),
+  created: textColumn<Row>(
+    { label: "Created", size: { width: 72 }, sort: "created" },
+    (item, now) => age(item.createdAt, now),
+    (item, now) => `opened ${age(item.createdAt, now)} ago`,
+  ),
   size: {
     label: "Size",
     size: { width: 80 },
     sort: "size",
-    cell: (item, colors) => (
+    line: (item: Row) => `${linesOf(item)} in ${filesOf(item)}`,
+    cell: (item: Row, colors: Colors) => (
       <View>
         <Cell colors={colors} text={linesOf(item)} color="foregroundMuted" />
         <Cell colors={colors} text={filesOf(item)} color="foregroundMuted" />
       </View>
     ),
   },
-  ci: { label: "CI", size: { width: 64 }, cell: (item, colors) => <TintedCell colors={colors} value={ciOf(item)} /> },
-  state: { label: "My review", size: { flex: 1.4, min: 96 }, cell: (item, colors) => <TintedCell colors={colors} value={stateOf(item)} /> },
-  local: { label: "Here", size: { flex: 1.4, min: 96 }, cell: (item, colors) => <TintedCell colors={colors} value={localOf(item)} /> },
+  ci: tintedColumn<Row>({ label: "CI", hint: "Whether the head's pipeline or checks passed", size: { width: 64 } }, ciOf),
+  local: tintedColumn<Row>({ label: "Here", hint: "The guide and drafts you have for it in this plugin", size: { flex: 1.4, min: 96 } }, localOf),
+} satisfies Record<string, ColumnSpec<Row>>;
+
+function checkedColumn(hint: string): ColumnSpec<Row> {
+  return { label: "Checked off", header: "", hint, size: { width: 20 }, besideTitle: true, cell: (item, colors) => <CheckOffBox colors={colors} item={item} /> };
+}
+
+const ASSIGNED_SPECS: Record<AssignedColumn, ColumnSpec<InboxItem>> = {
+  ...ROW_COLUMNS,
+  checked: checkedColumn("Set a review aside here until it is pushed to or you are asked again"),
+  author: textColumn<InboxItem>({ label: "Author", size: { flex: 1, min: 64 } }, (item) => item.author, (item) => item.author),
+  state: tintedColumn<InboxItem>({ label: "My review", hint: "Where you stand, and whether it changed since your review", size: { flex: 1.4, min: 96 } }, stateOf),
+};
+
+const AUTHORED_SPECS: Record<AuthoredColumn, ColumnSpec<AuthoredInboxItem>> = {
+  ...ROW_COLUMNS,
+  checked: checkedColumn("Set it aside here until a reviewer reviews again or its review status changes"),
+  reviewers: {
+    label: "Reviewers",
+    hint: "Who is asked or reviewed, tinted by where each stands",
+    size: { flex: 1.4, min: 96 },
+    tint: reviewersOf,
+    cell: (item, colors) => <ReviewersCell colors={colors} reviewers={reviewersOf(item)} />,
+  },
+  state: tintedColumn<AuthoredInboxItem>({ label: "State", hint: "Where your reviewers stand, and whether one reviewed since your last push", size: { flex: 1.4, min: 96 } }, statusOf),
+};
+
+const ASSIGNED_VIEW: TabView<InboxItem, ReviewerState, AssignedColumn> = {
+  tab: "assigned",
+  rules: ASSIGNED_RULES,
+  columns: ASSIGNED_COLUMNS,
+  specs: ASSIGNED_SPECS,
+  tinted: ["state", "local", "ci"],
+  states: {
+    all: ReviewerStateSchema.options,
+    label: statesLabel,
+    name: (state) => capitalised(STATE_NAMES[state]),
+    hint: (state) => (state === "unapproved" ? "GitLab only" : undefined),
+  },
+  searchHint: "Search by title, project, author or number",
+  listing: "Listing what you are asked to review…",
+  failure: "Could not list your reviews",
+  empty: "Nothing to review.",
+};
+
+const AUTHORED_VIEW: TabView<AuthoredInboxItem, ReviewStatus, AuthoredColumn> = {
+  tab: "authored",
+  rules: AUTHORED_RULES,
+  columns: AUTHORED_COLUMNS,
+  specs: AUTHORED_SPECS,
+  tinted: ["state", "reviewers", "local", "ci"],
+  states: {
+    all: ReviewStatusSchema.options,
+    label: statusesLabel,
+    name: (status) => capitalised(STATUS_NAMES[status]),
+    hint: (status) => STATUS_HINTS[status],
+  },
+  searchHint: "Search by title, project, reviewer or number",
+  listing: "Listing your change requests…",
+  failure: "Could not list your change requests",
+  empty: "No open change requests of yours.",
 };
 
 const ACTIONS_WIDTH = 88;
@@ -398,9 +733,9 @@ function columnStyle(size: ColumnWidth) {
 }
 
 /** The narrowest the table can be with these columns before its cells crowd; anything narrower gets cards. */
-function tableWidth(columns: readonly InboxColumn[]): number {
+function tableWidth<Item, Column extends string>(specs: Record<Column, ColumnSpec<Item>>, columns: readonly Column[]): number {
   const cells = columns.reduce((total, column) => {
-    const { size } = COLUMNS[column];
+    const { size } = specs[column];
     return total + ("width" in size ? size.width : size.min);
   }, 0);
   return cells + ACTIONS_WIDTH + CELL_GAP * columns.length + spacing[3] * 2 + 2;
@@ -420,7 +755,7 @@ function TintedCell({ colors, value }: { colors: Colors; value: Tinted | null })
 }
 
 /** The change request's number as its forge writes it, linking to it there. */
-function NumberLink({ colors, item }: { colors: Colors; item: InboxItem }) {
+function NumberLink({ colors, item }: { colors: Colors; item: Row }) {
   return (
     <ExternalLink href={item.url} accessibilityLabel={`Open ${numberLabel(item.forge, item.number)} on ${FORGE_NAMES[item.forge]}`}>
       <Text style={{ color: colors.accent, fontSize: fontSize.sm, lineHeight: leading(fontSize.sm) }}>{numberLabel(item.forge, item.number)}</Text>
@@ -428,7 +763,7 @@ function NumberLink({ colors, item }: { colors: Colors; item: InboxItem }) {
   );
 }
 
-function Title({ colors, item }: { colors: Colors; item: InboxItem }) {
+function Title({ colors, item }: { colors: Colors; item: Row }) {
   return (
     <View style={{ flexDirection: "row", alignItems: "center", gap: spacing[1] }}>
       {item.isDraft ? <Badge colors={colors} text="Draft" /> : null}
@@ -450,7 +785,7 @@ function Badge({ colors, text }: { colors: Colors; text: string }) {
 /** How faint a row is that stays only because it was just checked off or unchecked. */
 const DIMMED = 0.5;
 
-function CheckOffBox({ colors, item }: { colors: Colors; item: InboxItem }) {
+function CheckOffBox({ colors, item }: { colors: Colors; item: ListedItem }) {
   const { toggle } = useContext(CheckOffContext);
   const checked = item.checkedOff;
   return (
@@ -481,7 +816,7 @@ function CheckOffBox({ colors, item }: { colors: Colors; item: InboxItem }) {
  * The one way into the review from a row: a row itself starts nothing, so a click elsewhere on it is safe.
  * Review prepares a review without opening it, so several can be started in a row; Continue makes a closed review a workspace again and opens it.
  */
-function StartButton({ colors, item, starts }: { colors: Colors; item: InboxItem; starts: ReviewStarts }) {
+function StartButton({ colors, item, starts }: { colors: Colors; item: Row; starts: ReviewStarts }) {
   const { local } = item;
   const preparing = local?.preparing != null && local.preparing.phase !== "failed";
   if (starts.requesting(item.url) || preparing) return <Button colors={colors} small label="Starting…" disabled onPress={() => {}} />;
@@ -515,7 +850,7 @@ function StartStatus({ colors, url, reviewId, local, label, starts }: { colors:
  * A line per review started from the New review dialog that the list does not show, since what was pasted may not be in it.
  * It names the URL until the change request is read, and stays until closed.
  */
-function PastedRows({ colors, starts, shown }: { colors: Colors; starts: ReviewStarts; shown: readonly InboxItem[] }) {
+function PastedRows({ colors, starts, shown }: { colors: Colors; starts: ReviewStarts; shown: readonly Row[] }) {
   const listed = new Set(shown.map((item) => item.reviewId));
   const rows = starts.pasted.filter((entry) => !listed.has(entry.reviewId));
   if (rows.length === 0) return null;
@@ -566,26 +901,30 @@ function PastedRow({ colors, entry, starts }: { colors: Colors; entry: Pasted; s
 }
 
 /** How the start from this row is going, under it. */
-function RowStatus({ colors, item, starts }: { colors: Colors; item: InboxItem; starts: ReviewStarts }) {
+function RowStatus({ colors, item, starts }: { colors: Colors; item: Row; starts: ReviewStarts }) {
   return <StartStatus colors={colors} url={item.url} reviewId={item.reviewId} local={item.local} label={numberLabel(item.forge, item.number)} starts={starts} />;
 }
 
-function Table({
+function Table<Item extends Row, Column extends string>({
   colors,
   items,
+  specs,
+  columns: shown,
   preferences,
   change,
   starts,
 }: {
   colors: Colors;
-  items: InboxItem[];
-  preferences: InboxPreferences;
-  change: (update: Partial<InboxPreferences>) => void;
+  items: Item[];
+  specs: Record<Column, ColumnSpec<Item>>;
+  columns: readonly Column[];
+  preferences: Pick<ListFilters<string>, "sort">;
+  change: (update: Pick<ListFilters<string>, "sort">) => void;
   starts: ReviewStarts;
 }) {
   const now = new Date();
   const { dimmed } = useContext(CheckOffContext);
-  const columns = preferences.columns.map((id) => ({ id, ...COLUMNS[id] }));
+  const columns = shown.map((id) => ({ id, ...specs[id] }));
   const sortBy = (key: InboxSortKey) =>
     change({ sort: { key, descending: preferences.sort.key === key ? !preferences.sort.descending : true } });
 
@@ -648,26 +987,33 @@ function Table({
 }
 
 /** A row stacked for a narrow screen: the title, then whichever of the other columns are shown, as lines. */
-function Card({ colors, item, columns, starts }: { colors: Colors; item: InboxItem; columns: readonly InboxColumn[]; starts: ReviewStarts }) {
+function Card<Item extends Row, Column extends string>({
+  colors,
+  item,
+  specs,
+  columns,
+  tinted: tintedColumns,
+  starts,
+}: {
+  colors: Colors;
+  item: Item;
+  specs: Record<Column, ColumnSpec<Item>>;
+  columns: readonly Column[];
+  tinted: readonly Column[];
+  starts: ReviewStarts;
+}) {
   const now = new Date();
   const { dimmed } = useContext(CheckOffContext);
-  const shown = (column: InboxColumn) => columns.includes(column);
-  const meta = [
-    ...(shown("change") ? [item.project] : []),
-    ...(shown("author") ? [item.author] : []),
-    ...(shown("updated") ? [`updated ${age(item.updatedAt, now)} ago`] : []),
-    ...(shown("created") ? [`opened ${age(item.createdAt, now)} ago`] : []),
-    ...(shown("size") ? [`${linesOf(item)} in ${filesOf(item)}`] : []),
-  ];
-  const tinted = [shown("state") ? stateOf(item) : null, shown("local") ? localOf(item) : null, shown("ci") ? ciOf(item) : null].filter(
-    (value) => value !== null,
-  );
+  const shown = columns.map((column) => specs[column]);
+  const beside = shown.find((spec) => spec.besideTitle);
+  const meta = shown.flatMap((spec) => (spec.line === undefined ? [] : [spec.line(item, now)]));
+  const tinted = tintedColumns.filter((column) => columns.includes(column)).flatMap((column) => specs[column].tint?.(item) ?? []);
 
   return (
     <View style={{ padding: spacing[3], gap: spacing[1], borderWidth: 1, borderColor: colors.border, borderRadius: radius.md, opacity: dimmed(item) ? DIMMED : 1 }}>
-      {shown("checked") ? (
+      {beside !== undefined ? (
         <View style={{ flexDirection: "row", alignItems: "center", gap: spacing[2] }}>
-          <CheckOffBox colors={colors} item={item} />
+          {beside.cell(item, colors, now)}
           <Title colors={colors} item={item} />
         </View>
       ) : (
@@ -681,8 +1027,8 @@ function Card({ colors, item, columns, starts }: { colors: Colors; item: InboxIt
       </View>
       {tinted.length > 0 ? (
         <View style={{ flexDirection: "row", flexWrap: "wrap", columnGap: spacing[3] }}>
-          {tinted.map((value) => (
-            <Cell key={value.text} colors={colors} text={value.text} color={value.color} />
+          {tinted.map((value, index) => (
+            <Cell key={index} colors={colors} text={value.text} color={value.color} />
           ))}
         </View>
       ) : null}
diff --git a/plugins/guided-review/client/start-review.ts b/plugins/guided-review/client/start-review.ts
index c80bc34..4a18b2e 100644
--- a/plugins/guided-review/client/start-review.ts
+++ b/plugins/guided-review/client/start-review.ts
@@ -39,7 +39,7 @@ export type ReviewStarts = {
  * Starts reviews, follows each one's preparation and guide until they settle, and opens a panel only for a start meant to open it.
  * `items` are the listed reviews, whose unsettled ones are followed too, as after the start screen was closed and opened again.
  */
-export function useReviewStarts(openPanel: (workspaceId: string) => void, items: readonly InboxItem[]): ReviewStarts {
+export function useReviewStarts(openPanel: (workspaceId: string) => void, items: readonly Pick<InboxItem, "reviewId" | "local">[]): ReviewStarts {
   const startReview = useRpc(contracts.startReview);
   const getLocalReviews = useRpc(contracts.getLocalReviews);
   const [requesting, setRequesting] = useState<ReadonlySet<string>>(new Set());
diff --git a/plugins/guided-review/client/start-sidebar-item.tsx b/plugins/guided-review/client/start-sidebar-item.tsx
index eef3c4c..fd50b01 100644
--- a/plugins/guided-review/client/start-sidebar-item.tsx
+++ b/plugins/guided-review/client/start-sidebar-item.tsx
@@ -17,7 +17,7 @@ import { fontSize, leading } from "./theme.ts";
 export function StartSidebarItem({ theme, currentScreen, openScreen }: PluginSidebarItemProps) {
   const getInbox = useRpc(contracts.getInbox);
   const inbox = useQuery({ queryKey: INBOX_QUERY_KEY, queryFn: () => getInbox({}), staleTime: Infinity, refetchOnWindowFocus: false });
-  const count = inbox.data ? attentionCount(inbox.data.items) : 0;
+  const count = inbox.data ? attentionCount(inbox.data) : 0;
 
   return (
     <SidebarRow
diff --git a/plugins/guided-review/server/fake-forge.ts b/plugins/guided-review/server/fake-forge.ts
index f7c4090..5f10776 100644
--- a/plugins/guided-review/server/fake-forge.ts
+++ b/plugins/guided-review/server/fake-forge.ts
@@ -3,7 +3,7 @@ import path from "node:path";
 import { parsePullRequestUrl } from "./forge/github.ts";
 import { parseMergeRequestUrl } from "./forge/gitlab.ts";
 import { lineRefOf, type Draft, type DraftLocation } from "../shared/drafts.ts";
-import type { ReviewRequestHost } from "../shared/inbox.ts";
+import type { ListedHost } from "../shared/inbox.ts";
 import {
   ForgeError,
   type BranchChangeRequest,
@@ -72,8 +72,8 @@ export type FakeForge = Forge & {
   submitOutcome: SubmitOutcome | null;
   /** The URL of every change request whose pending review was discarded. */
   discarded: string[];
-  /** What `listReviewRequests` answers, host by host. */
-  reviewRequests: ReviewRequestHost[];
+  /** What `listChangeRequests` answers, host by host. */
+  listedHosts: ListedHost[];
 };
 
 /** Where the forge says a draft on `anchor` is: a line by the side both forges put it on. */
@@ -118,7 +118,7 @@ export function fakeForge(kind: ForgeKind = "github"): FakeForge {
     submissions: [],
     submitOutcome: null,
     discarded: [],
-    reviewRequests: [],
+    listedHosts: [],
     async matchUrl(url) {
       return PARSERS[kind](url);
     },
@@ -250,8 +250,8 @@ export function fakeForge(kind: ForgeKind = "github"): FakeForge {
       forge.discarded.push(ref.url);
       forge.drafts.delete(ref.url);
     },
-    async listReviewRequests() {
-      return structuredClone(forge.reviewRequests);
+    async listChangeRequests() {
+      return structuredClone(forge.listedHosts);
     },
   };
   return forge;
diff --git a/plugins/guided-review/server/forge/common.ts b/plugins/guided-review/server/forge/common.ts
index 7c93d18..b0a72a8 100644
--- a/plugins/guided-review/server/forge/common.ts
+++ b/plugins/guided-review/server/forge/common.ts
@@ -1,6 +1,7 @@
+import type { ListedHost, Reviewer, ReviewStatus } from "../../shared/inbox.ts";
 import type { ForgeUser } from "./port.ts";
 
-/** What both forge adapters share: the caps on what they read, and how an author with no account reads. */
+/** What both forge adapters share: the caps on what they read, how an author with no account reads, how reviewers' states combine, and how a host that could not be listed reads. */
 
 /** Cloning a large repository is the one call that can take minutes. */
 export const CLONE_TIMEOUT_MS = 10 * 60_000;
@@ -35,3 +36,26 @@ export const GHOST: ForgeUser = { login: "ghost", name: null };
 export function userOf(author: { login: string; name?: string | null | undefined } | null | undefined): ForgeUser {
   return author ? { login: author.login, name: author.name ?? null } : GHOST;
 }
+
+/**
+ * Where an authored change request stands from each reviewer's latest state, by the same rule on both forges.
+ * A change request beats any approval, and an approval still standing beats one taken back.
+ */
+export function reviewStatusOf(reviewers: readonly Reviewer[]): ReviewStatus {
+  const states = new Set(reviewers.map((reviewer) => reviewer.state));
+  if (states.has("changes-requested")) return "changes-requested";
+  if (states.has("approved")) return "approved";
+  if (states.has("unapproved")) return "approval-reset";
+  if (states.has("commented")) return "commented";
+  return states.has("requested") ? "waiting" : "unreviewed";
+}
+
+/** The latest of some ISO times, as the forge wrote it; null for none. */
+export function latestOf(times: readonly string[]): string | null {
+  return times.reduce<string | null>((latest, at) => (latest === null || Date.parse(at) > Date.parse(latest) ? at : latest), null);
+}
+
+/** A host that could not be listed, with why. */
+export function unlistedHost(forge: ListedHost["forge"], host: string, error: string): ListedHost {
+  return { forge, host, assigned: [], authored: [], truncated: { assigned: false, authored: false }, error };
+}
diff --git a/plugins/guided-review/server/forge/fixtures/github/review-search-authored.json b/plugins/guided-review/server/forge/fixtures/github/review-search-authored.json
new file mode 100644
index 0000000..8110324
--- /dev/null
+++ b/plugins/guided-review/server/forge/fixtures/github/review-search-authored.json
@@ -0,0 +1,133 @@
+{
+  "data": {
+    "search": {
+      "issueCount": 2,
+      "nodes": [
+        {
+          "number": 31,
+          "url": "https://github.com/example-org/uploader/pull/31",
+          "title": "Resume uploads after a dropped connection",
+          "isDraft": false,
+          "createdAt": "2026-10-01T08:30:00Z",
+          "updatedAt": "2026-10-06T16:45:12Z",
+          "headRefOid": "3c9e0b7a1f2d4e6c8b0a9f8e7d6c5b4a39281706",
+          "additions": 128,
+          "deletions": 14,
+          "changedFiles": 5,
+          "author": {
+            "login": "sleeyax"
+          },
+          "statusCheckRollup": {
+            "state": "FAILURE"
+          },
+          "reviews": {
+            "nodes": [
+              {
+                "viewerDidAuthor": true,
+                "comments": {
+                  "totalCount": 1
+                }
+              }
+            ]
+          },
+          "reviewRequests": {
+            "nodes": [
+              {
+                "requestedReviewer": {
+                  "__typename": "Team",
+                  "combinedSlug": "example-org/backend"
+                }
+              }
+            ]
+          },
+          "latestReviews": {
+            "nodes": [
+              {
+                "state": "APPROVED",
+                "submittedAt": "2026-10-06T15:02:40Z",
+                "author": {
+                  "login": "alice"
+                },
+                "commit": {
+                  "oid": "3c9e0b7a1f2d4e6c8b0a9f8e7d6c5b4a39281706"
+                }
+              },
+              {
+                "state": "CHANGES_REQUESTED",
+                "submittedAt": "2026-10-03T09:14:05Z",
+                "author": {
+                  "login": "bob"
+                },
+                "commit": {
+                  "oid": "0b1c2d3e4f5a6b7c8d9e0f1a2b3c4d5e6f7a8b9c"
+                }
+              },
+              {
+                "state": "COMMENTED",
+                "submittedAt": "2026-10-06T16:40:00Z",
+                "author": {
+                  "login": "sleeyax"
+                },
+                "commit": {
+                  "oid": "3c9e0b7a1f2d4e6c8b0a9f8e7d6c5b4a39281706"
+                }
+              }
+            ]
+          },
+          "latestOpinionatedReviews": {
+            "nodes": [
+              {
+                "state": "APPROVED",
+                "submittedAt": "2026-10-06T15:02:40Z",
+                "author": {
+                  "login": "alice"
+                }
+              },
+              {
+                "state": "CHANGES_REQUESTED",
+                "submittedAt": "2026-10-03T09:14:05Z",
+                "author": {
+                  "login": "bob"
+                }
+              }
+            ]
+          },
+          "timelineItems": {
+            "nodes": []
+          }
+        },
+        {
+          "number": 4,
+          "url": "https://github.com/example-org/docs/pull/4",
+          "title": "Describe the retry settings",
+          "isDraft": true,
+          "createdAt": "2026-10-05T11:00:00Z",
+          "updatedAt": "2026-10-05T11:20:00Z",
+          "headRefOid": "9a8b7c6d5e4f3a2b1c0d9e8f7a6b5c4d3e2f1a0b",
+          "additions": 6,
+          "deletions": 0,
+          "changedFiles": 1,
+          "author": {
+            "login": "sleeyax"
+          },
+          "statusCheckRollup": null,
+          "reviews": {
+            "nodes": []
+          },
+          "reviewRequests": {
+            "nodes": []
+          },
+          "latestReviews": {
+            "nodes": []
+          },
+          "latestOpinionatedReviews": {
+            "nodes": []
+          },
+          "timelineItems": {
+            "nodes": []
+          }
+        }
+      ]
+    }
+  }
+}
diff --git a/plugins/guided-review/server/forge/fixtures/gitlab/review-list.json b/plugins/guided-review/server/forge/fixtures/gitlab/review-list.json
index 06a5f23..bd0647a 100644
--- a/plugins/guided-review/server/forge/fixtures/gitlab/review-list.json
+++ b/plugins/guided-review/server/forge/fixtures/gitlab/review-list.json
@@ -203,6 +203,119 @@
             }
           }
         ]
+      },
+      "authoredMergeRequests": {
+        "pageInfo": {
+          "hasNextPage": false
+        },
+        "nodes": [
+          {
+            "webUrl": "https://gitlab.com/example-group/service/-/merge_requests/15",
+            "title": "Stream large uploads to storage",
+            "draft": false,
+            "createdAt": "2026-10-01T08:00:00Z",
+            "updatedAt": "2026-10-05T09:30:00Z",
+            "diffHeadSha": "6666666666666666666666666666666666666666",
+            "author": {
+              "username": "reviewer"
+            },
+            "diffStatsSummary": {
+              "additions": 210,
+              "deletions": 44,
+              "fileCount": 7
+            },
+            "headPipeline": {
+              "status": "SUCCESS"
+            },
+            "commits": {
+              "nodes": [
+                {
+                  "sha": "6666666666666666666666666666666666666666",
+                  "committedDate": "2026-10-05T09:00:00+00:00"
+                }
+              ]
+            },
+            "reviewers": {
+              "nodes": [
+                {
+                  "username": "maintainer",
+                  "mergeRequestInteraction": {
+                    "reviewState": "APPROVED",
+                    "approved": true,
+                    "updatedAt": "2026-10-05T10:15:00Z"
+                  }
+                },
+                {
+                  "username": "designer",
+                  "mergeRequestInteraction": {
+                    "reviewState": "REQUESTED_CHANGES",
+                    "approved": false,
+                    "updatedAt": "2026-10-03T14:00:00Z"
+                  }
+                },
+                {
+                  "username": "backend-lead",
+                  "mergeRequestInteraction": {
+                    "reviewState": "UNREVIEWED",
+                    "approved": false,
+                    "updatedAt": "2026-10-01T09:00:00Z"
+                  }
+                }
+              ]
+            },
+            "approvedBy": {
+              "nodes": [
+                {
+                  "username": "maintainer"
+                },
+                {
+                  "username": "passer-by"
+                }
+              ]
+            },
+            "mergeRequestDiffs": {
+              "nodes": [
+                {
+                  "createdAt": "2026-10-05T09:20:00Z"
+                }
+              ]
+            }
+          },
+          {
+            "webUrl": "https://gitlab.com/example-group/sub/web/-/merge_requests/43",
+            "title": "Draft: Resume an interrupted upload",
+            "draft": true,
+            "createdAt": "2026-10-02T08:00:00Z",
+            "updatedAt": "2026-10-02T08:10:00Z",
+            "diffHeadSha": null,
+            "author": {
+              "username": "reviewer"
+            },
+            "diffStatsSummary": null,
+            "headPipeline": null,
+            "commits": {
+              "nodes": [
+                {
+                  "sha": "7777777777777777777777777777777777777777",
+                  "committedDate": "2026-10-02T08:00:00+00:00"
+                }
+              ]
+            },
+            "reviewers": {
+              "nodes": []
+            },
+            "approvedBy": {
+              "nodes": []
+            },
+            "mergeRequestDiffs": {
+              "nodes": [
+                {
+                  "createdAt": "2026-10-02T08:05:00Z"
+                }
+              ]
+            }
+          }
+        ]
       }
     }
   }
diff --git a/plugins/guided-review/server/forge/github.test.ts b/plugins/guided-review/server/forge/github.test.ts
index cf0eb4c..31f7878 100644
--- a/plugins/guided-review/server/forge/github.test.ts
+++ b/plugins/guided-review/server/forge/github.test.ts
@@ -5,6 +5,7 @@ import test from "node:test";
 import { fakeCommandRunner, type FakeCommandRunner, type ScriptedResult } from "../fake-command-runner.ts";
 import {
   ADD_THREAD_MUTATION,
+  AUTHORED_SEARCH_QUERY,
   COMMIT_PULL_REQUESTS_QUERY,
   createGitHubForge,
   MAX_COMPARE_FILES,
@@ -716,10 +717,19 @@ test("a discussion on the pull request is a comment on its conversation, as GitH
   assert.deepEqual(run.calls[0]?.args, ["api", "--hostname", "github.com", "--method", "POST", "repos/sleeyax/paseo-plugins/issues/105/comments", "--input", "-"]);
 });
 
-test("lists what the viewer is asked to review and what they reviewed, as two searches on github.com", async () => {
-  const { forge, run } = forgeReplaying([{ stdout: fixture("review-search-requested.json") }, { stdout: fixture("review-search-reviewed.json") }]);
+/** A listing's three searches as gh answers them, in the order they go out: asked to review, reviewed, authored. */
+function searches(answers: { requested?: ScriptedResult; reviewed?: ScriptedResult; authored?: ScriptedResult } = {}): ScriptedResult[] {
+  return [
+    answers.requested ?? { stdout: fixture("review-search-requested.json") },
+    answers.reviewed ?? { stdout: fixture("review-search-reviewed.json") },
+    answers.authored ?? { stdout: fixture("review-search-authored.json") },
+  ];
+}
 
-  const [host, ...others] = await forge.listReviewRequests();
+test("lists what the viewer is asked to review, what they reviewed and what they authored, as three searches on github.com", async () => {
+  const { forge, run } = forgeReplaying(searches());
+
+  const [host, ...others] = await forge.listChangeRequests();
 
   assert.deepEqual(others, []);
   assert.deepEqual(
@@ -727,19 +737,21 @@ test("lists what the viewer is asked to review and what they reviewed, as two se
     [
       ["api", "graphql", "--hostname", "github.com", "--input", "-"],
       ["api", "graphql", "--hostname", "github.com", "--input", "-"],
+      ["api", "graphql", "--hostname", "github.com", "--input", "-"],
     ],
   );
   assert.deepEqual(graphqlCalls(run), [
     { query: REVIEW_SEARCH_QUERY, variables: { query: REVIEW_SEARCHES.requested } },
     { query: REVIEW_SEARCH_QUERY, variables: { query: REVIEW_SEARCHES.reviewed } },
+    { query: AUTHORED_SEARCH_QUERY, variables: { query: REVIEW_SEARCHES.authored } },
   ]);
   assert.equal(host?.forge, "github");
   assert.equal(host?.host, "github.com");
   assert.equal(host?.error, null);
-  assert.equal(host?.truncated, false);
-  assert.equal(host?.requests.length, 7);
+  assert.deepEqual(host?.truncated, { assigned: false, authored: false });
+  assert.equal(host?.assigned.length, 7);
 
-  assert.deepEqual(host?.requests[0], {
+  assert.deepEqual(host?.assigned[0], {
     forge: "github",
     host: "github.com",
     project: "sleeyax/paseo-plugins",
@@ -763,10 +775,10 @@ test("lists what the viewer is asked to review and what they reviewed, as two se
 });
 
 test("a PR the viewer is asked to review again reads as requested and changed, with the team it was asked of", async () => {
-  const { forge } = forgeReplaying([{ stdout: fixture("review-search-requested.json") }, { stdout: fixture("review-search-reviewed.json") }]);
+  const { forge } = forgeReplaying(searches());
 
-  const [host] = await forge.listReviewRequests();
-  const again = host?.requests.find((request) => request.number === 7);
+  const [host] = await forge.listChangeRequests();
+  const again = host?.assigned.find((request) => request.number === 7);
 
   assert.equal(again?.author, "ghost");
   assert.equal(again?.isDraft, true);
@@ -778,10 +790,10 @@ test("a PR the viewer is asked to review again reads as requested and changed, w
 });
 
 test("a PR the viewer reviewed and is not asked again reads by their review, changed when the head moved past it", async () => {
-  const { forge } = forgeReplaying([{ stdout: fixture("review-search-requested.json") }, { stdout: fixture("review-search-reviewed.json") }]);
+  const { forge } = forgeReplaying(searches());
 
-  const [host] = await forge.listReviewRequests();
-  const byUrl = (url: string) => host?.requests.find((request) => request.url === url);
+  const [host] = await forge.listChangeRequests();
+  const byUrl = (url: string) => host?.assigned.find((request) => request.url === url);
 
   const commented = byUrl("https://github.com/themouette/claude-vm/pull/96");
   assert.equal(commented?.state, "commented");
@@ -792,10 +804,10 @@ test("a PR the viewer reviewed and is not asked again reads by their review, cha
 });
 
 test("a PR the viewer reviewed without being asked, by name or through a team, is left out", async () => {
-  const { forge } = forgeReplaying([{ stdout: fixture("review-search-requested.json") }, { stdout: fixture("review-search-reviewed.json") }]);
+  const { forge } = forgeReplaying(searches());
 
-  const [host] = await forge.listReviewRequests();
-  const urls = host?.requests.map((request) => request.url);
+  const [host] = await forge.listChangeRequests();
+  const urls = host?.assigned.map((request) => request.url);
 
   assert.ok(!urls?.includes("https://github.com/magisterquis/connectproxy/pull/2"));
   assert.ok(!urls?.includes("https://github.com/sickcodes/Docker-OSX/pull/819"));
@@ -803,27 +815,202 @@ test("a PR the viewer reviewed without being asked, by name or through a team, i
   assert.ok(urls?.includes("https://github.com/stretchr/testify/pull/1467"));
 });
 
-test("a search with more results than it returned marks the host as truncated", async () => {
-  const requested = JSON.parse(fixture("review-search-requested.json"));
-  requested.data.search.issueCount = 120;
-  const { forge } = forgeReplaying([{ stdout: JSON.stringify(requested) }, { stdout: fixture("review-search-reviewed.json") }]);
+test("a search with more results than it returned marks its list on the host as truncated", async () => {
+  const more = (name: string) => {
+    const answer = JSON.parse(fixture(name));
+    answer.data.search.issueCount = 120;
+    return { stdout: JSON.stringify(answer) };
+  };
 
-  const [host] = await forge.listReviewRequests();
+  const [assigned] = await forgeReplaying(searches({ requested: more("review-search-requested.json") })).forge.listChangeRequests();
+  const [authored] = await forgeReplaying(searches({ authored: more("review-search-authored.json") })).forge.listChangeRequests();
 
-  assert.equal(host?.truncated, true);
+  assert.deepEqual(assigned?.truncated, { assigned: true, authored: false });
+  assert.deepEqual(authored?.truncated, { assigned: false, authored: true });
 });
 
-test("a search gh cannot run comes back as the host's error rather than a throw", async () => {
-  const { forge } = forgeReplaying([
-    { exitCode: 4, stderr: "To get started with GitHub CLI, please run:  gh auth login\n" },
-    { stdout: fixture("review-search-reviewed.json") },
+test("a search gh cannot run comes back as the host's error once, with both lists empty, rather than a throw", async () => {
+  const failed = { exitCode: 4, stderr: "To get started with GitHub CLI, please run:  gh auth login\n" };
+  const error = {
+    forge: "github",
+    host: "github.com",
+    assigned: [],
+    authored: [],
+    truncated: { assigned: false, authored: false },
+    error: "gh failed: To get started with GitHub CLI, please run:  gh auth login",
+  };
+
+  assert.deepEqual(await forgeReplaying(searches({ requested: failed })).forge.listChangeRequests(), [error]);
+  assert.deepEqual(await forgeReplaying(searches({ authored: failed })).forge.listChangeRequests(), [error]);
+});
+
+test("the viewer's own open PRs list as authored, drafts included, with their own pending drafts and where their reviewers stand", async () => {
+  const [host] = await forgeReplaying(searches()).forge.listChangeRequests();
+
+  assert.deepEqual(host?.authored, [
+    {
+      forge: "github",
+      host: "github.com",
+      project: "example-org/uploader",
+      number: 31,
+      url: "https://github.com/example-org/uploader/pull/31",
+      title: "Resume uploads after a dropped connection",
+      author: "sleeyax",
+      isDraft: false,
+      createdAt: "2026-10-01T08:30:00Z",
+      updatedAt: "2026-10-06T16:45:12Z",
+      headSha: "3c9e0b7a1f2d4e6c8b0a9f8e7d6c5b4a39281706",
+      additions: 128,
+      deletions: 14,
+      fileCount: 5,
+      ci: "failure",
+      pendingDrafts: 1,
+      status: "changes-requested",
+      reviewers: [
+        { name: "alice", state: "approved" },
+        { name: "bob", state: "changes-requested" },
+        { name: "example-org/backend", state: "requested" },
+      ],
+      reviewedSinceLastPush: true,
+      latestReviewAt: "2026-10-06T15:02:40Z",
+    },
+    {
+      forge: "github",
+      host: "github.com",
+      project: "example-org/docs",
+      number: 4,
+      url: "https://github.com/example-org/docs/pull/4",
+      title: "Describe the retry settings",
+      author: "sleeyax",
+      isDraft: true,
+      createdAt: "2026-10-05T11:00:00Z",
+      updatedAt: "2026-10-05T11:20:00Z",
+      headSha: "9a8b7c6d5e4f3a2b1c0d9e8f7a6b5c4d3e2f1a0b",
+      additions: 6,
+      deletions: 0,
+      fileCount: 1,
+      ci: null,
+      pendingDrafts: 0,
+      status: "unreviewed",
+      reviewers: [],
+      reviewedSinceLastPush: false,
+      latestReviewAt: null,
+    },
   ]);
+});
+
+const HEAD_31 = "3c9e0b7a1f2d4e6c8b0a9f8e7d6c5b4a39281706";
+const EARLIER_31 = "0b1c2d3e4f5a6b7c8d9e0f1a2b3c4d5e6f7a8b9c";
+
+type LatestReview = { state: string; submittedAt: string; author: { login: string }; commit: { oid: string } };
 
-  const hosts = await forge.listReviewRequests();
+function review(login: string, state: string, commit = HEAD_31, submittedAt = "2026-10-06T15:00:00Z"): LatestReview {
+  return { state, submittedAt, author: { login }, commit: { oid: commit } };
+}
+
+/** GitHub dismissing `login`'s approval submitted at `submittedAt`, on a push or by hand. */
+function dismissal(login: string, pushed: boolean, submittedAt = "2026-10-04T10:00:00Z") {
+  return { previousReviewState: "APPROVED", pullRequestCommit: pushed ? { id: "PURC_1" } : null, review: { author: { login }, submittedAt } };
+}
+
+/**
+ * The authored PR #31 as the search answers it, with these reviewers asked, reviews and dismissals in place of the fixture's.
+ * `reviews` is each reviewer's latest review, and `opinions` their latest approval or change request, which by default are the verdicts among `reviews`.
+ */
+async function authored31(pr: { asked?: string[]; reviews?: LatestReview[]; opinions?: LatestReview[]; dismissals?: object[] }) {
+  const answer = JSON.parse(fixture("review-search-authored.json"));
+  const node = answer.data.search.nodes[0];
+  const reviews = pr.reviews ?? [];
+  node.reviewRequests.nodes = (pr.asked ?? []).map((login) => ({ requestedReviewer: { __typename: "User", login } }));
+  node.latestReviews.nodes = reviews;
+  node.latestOpinionatedReviews.nodes = pr.opinions ?? reviews.filter((latest) => latest.state === "APPROVED" || latest.state === "CHANGES_REQUESTED");
+  node.timelineItems.nodes = pr.dismissals ?? [];
+  const [host] = await forgeReplaying(searches({ authored: { stdout: JSON.stringify(answer) } })).forge.listChangeRequests();
+  return host!.authored[0]!;
+}
 
-  assert.deepEqual(hosts, [
-    { forge: "github", host: "github.com", requests: [], truncated: false, error: "gh failed: To get started with GitHub CLI, please run:  gh auth login" },
+test("an approval GitHub dismissed on a push reads as an approval reset, and one dismissed by hand does not", async () => {
+  const dismissed = [review("alice", "DISMISSED", EARLIER_31, "2026-10-04T10:00:00Z")];
+
+  const reset = await authored31({ reviews: dismissed, dismissals: [dismissal("alice", true)] });
+  const byHand = await authored31({ reviews: dismissed, dismissals: [dismissal("alice", false)] });
+
+  assert.equal(reset.status, "approval-reset");
+  assert.deepEqual(reset.reviewers, [{ name: "alice", state: "unapproved" }]);
+  assert.equal(byHand.status, "commented");
+  assert.deepEqual(byHand.reviewers, [{ name: "alice", state: "commented" }]);
+});
+
+test("a comment after an approval leaves the approval standing", async () => {
+  const approved = await authored31({
+    reviews: [review("alice", "COMMENTED", HEAD_31, "2026-10-06T15:00:00Z")],
+    opinions: [review("alice", "APPROVED", EARLIER_31, "2026-10-04T10:00:00Z")],
+  });
+
+  assert.equal(approved.status, "approved");
+  assert.deepEqual(approved.reviewers, [{ name: "alice", state: "approved" }]);
+  assert.equal(approved.reviewedSinceLastPush, true);
+  assert.equal(approved.latestReviewAt, "2026-10-06T15:00:00Z");
+});
+
+test("a comment after a change request leaves the change request standing", async () => {
+  const blocked = await authored31({
+    reviews: [review("bob", "COMMENTED", HEAD_31, "2026-10-06T15:00:00Z")],
+    opinions: [review("bob", "CHANGES_REQUESTED", EARLIER_31, "2026-10-04T10:00:00Z")],
+  });
+
+  assert.equal(blocked.status, "changes-requested");
+  assert.deepEqual(blocked.reviewers, [{ name: "bob", state: "changes-requested" }]);
+});
+
+test("an approval GitHub dismissed on a push stays reset through a later comment, until the reviewer approves again", async () => {
+  const commentedSince = await authored31({ reviews: [review("alice", "COMMENTED")], dismissals: [dismissal("alice", true)] });
+  const approvedAgain = await authored31({ reviews: [review("alice", "APPROVED")], dismissals: [dismissal("alice", true)] });
+
+  assert.equal(commentedSince.status, "approval-reset");
+  assert.deepEqual(commentedSince.reviewers, [{ name: "alice", state: "unapproved" }]);
+  assert.deepEqual(approvedAgain.reviewers, [{ name: "alice", state: "approved" }]);
+});
+
+test("an approval still standing beats one GitHub took back, and a change request beats both", async () => {
+  const approved = [review("alice", "APPROVED"), review("bob", "DISMISSED", EARLIER_31, "2026-10-04T10:00:00Z")];
+  const reset = [dismissal("bob", true)];
+
+  assert.equal((await authored31({ reviews: approved, dismissals: reset })).status, "approved");
+  assert.equal((await authored31({ reviews: [...approved, review("carol", "CHANGES_REQUESTED", EARLIER_31)], dismissals: reset })).status, "changes-requested");
+});
+
+test("reviewers asked and none answered is waiting, and a review without a verdict is commented", async () => {
+  const waiting = await authored31({ asked: ["alice", "bob"] });
+  const commented = await authored31({ asked: ["bob"], reviews: [review("alice", "COMMENTED", EARLIER_31, "2026-10-04T10:00:00Z")] });
+
+  assert.equal(waiting.status, "waiting");
+  assert.deepEqual(waiting.reviewers, [
+    { name: "alice", state: "requested" },
+    { name: "bob", state: "requested" },
   ]);
+  assert.equal(waiting.reviewedSinceLastPush, false);
+  assert.equal(waiting.latestReviewAt, null);
+  assert.equal(commented.status, "commented");
+  assert.equal(commented.reviewedSinceLastPush, false, "the review is of an earlier commit");
+  assert.equal(commented.latestReviewAt, "2026-10-04T10:00:00Z");
+});
+
+test("a reviewer asked again is waited on, and their review no longer counts as since the push", async () => {
+  const again = await authored31({ asked: ["alice"], reviews: [review("alice", "APPROVED")] });
+
+  assert.equal(again.status, "waiting");
+  assert.deepEqual(again.reviewers, [{ name: "alice", state: "requested" }]);
+  assert.equal(again.reviewedSinceLastPush, false);
+  assert.equal(again.latestReviewAt, "2026-10-06T15:00:00Z");
+});
+
+test("a reviewer asked again after requesting changes still holds them, and their review counts as since the push", async () => {
+  const again = await authored31({ asked: ["bob"], reviews: [review("bob", "CHANGES_REQUESTED")] });
+
+  assert.equal(again.status, "changes-requested");
+  assert.deepEqual(again.reviewers, [{ name: "bob", state: "changes-requested" }]);
+  assert.equal(again.reviewedSinceLastPush, true);
 });
 
 test("only GitHub's own attachment URLs are attachments", () => {
diff --git a/plugins/guided-review/server/forge/github.ts b/plugins/guided-review/server/forge/github.ts
index 06099e5..6e9aafc 100644
--- a/plugins/guided-review/server/forge/github.ts
+++ b/plugins/guided-review/server/forge/github.ts
@@ -3,9 +3,9 @@ import type { CommandRunner } from "../command-runner.ts";
 import { oneAtATimePer } from "../one-at-a-time.ts";
 import { createCli } from "./cli.ts";
 import type { Draft, DraftLocation } from "../../shared/drafts.ts";
-import type { CiState, ReviewerState, ReviewRequest, ReviewRequestHost } from "../../shared/inbox.ts";
+import type { AuthoredChangeRequest, CiState, ListedChangeRequest, ListedHost, ReviewerState, ReviewRequest } from "../../shared/inbox.ts";
 import type { Verdict } from "../../shared/submit.ts";
-import { CLONE_TIMEOUT_MS, MAX_BRANCH_CHANGE_REQUESTS, MAX_COMMITS, MAX_LINKED_ISSUES, userOf } from "./common.ts";
+import { CLONE_TIMEOUT_MS, MAX_BRANCH_CHANGE_REQUESTS, MAX_COMMITS, MAX_LINKED_ISSUES, latestOf, reviewStatusOf, unlistedHost, userOf } from "./common.ts";
 import { SubmitSteps } from "./submit-steps.ts";
 import {
   commitsSinceIn,
@@ -343,34 +343,40 @@ const SUBMIT_LABELS: Record<Verdict, string> = {
 };
 
 /**
- * GitHub drops a review request once the reviewer reviews, so what they are a reviewer of is two
- * searches: the requests outstanding, team requests included, and the ones they answered. Pages are
- * kept at half a GraphQL page, because a full one of these timed out as a 502.
+ * GitHub drops a review request once the reviewer reviews, so what they are a reviewer of is two searches: the requests outstanding, team requests included, and the ones they answered.
+ * What the viewer authored is a third search.
+ * Pages are kept at half a GraphQL page, because a full one of these timed out as a 502.
  * `reviewed-by` also finds reviews nobody asked for, so `wasAskedToReview` keeps only those asked of the viewer.
  */
 export const REVIEW_SEARCHES = {
   requested: "is:pr is:open review-requested:@me archived:false",
   reviewed: "is:pr is:open reviewed-by:@me -author:@me -review-requested:@me archived:false",
+  authored: "is:pr is:open author:@me archived:false",
 } as const;
 const REVIEW_SEARCH_SIZE = 50;
 const REVIEW_REQUEST_EVENTS = 20;
+/** More reviewers, or dismissals, than one PR gathers. */
+const AUTHORED_REVIEWERS = 20;
 
 /**
- * A pending review is visible only to its author, so the first one is the viewer's, and its comments
- * are their drafts. A PR author can be a deleted account, which GitHub gives as null.
+ * What every listed PR is read with.
+ * A pending review is visible only to its author, so the first one is the viewer's, and its comments are their drafts.
+ * A PR author can be a deleted account, which GitHub gives as null.
  */
+const LISTED_PULL_REQUEST_FIELDS = `number url title isDraft createdAt updatedAt headRefOid additions deletions changedFiles
+        author { login }
+        statusCheckRollup { state }
+        reviews(states: PENDING, first: 1) { nodes { viewerDidAuthor comments { totalCount } } }`;
+
 export const REVIEW_SEARCH_QUERY = `query GuidedReviewInbox($query: String!) {
   viewer { login }
   search(type: ISSUE, query: $query, first: ${REVIEW_SEARCH_SIZE}) {
     issueCount
     nodes {
       ... on PullRequest {
-        number url title isDraft createdAt updatedAt headRefOid additions deletions changedFiles
-        author { login }
-        statusCheckRollup { state }
+        ${LISTED_PULL_REQUEST_FIELDS}
         viewerLatestReview { state commit { oid } }
         viewerLatestReviewRequest { requestedReviewer { __typename ... on Team { combinedSlug } } }
-        reviews(states: PENDING, first: 1) { nodes { viewerDidAuthor comments { totalCount } } }
         timelineItems(itemTypes: [REVIEW_REQUESTED_EVENT], first: ${REVIEW_REQUEST_EVENTS}) {
           nodes { ... on ReviewRequestedEvent { requestedReviewer { __typename ... on User { login } } } }
         }
@@ -379,35 +385,59 @@ export const REVIEW_SEARCH_QUERY = `query GuidedReviewInbox($query: String!) {
   }
 }`;
 
+/**
+ * The viewer's own PRs, with who is asked to review each, every reviewer's latest review, their latest approval or change request, and the latest dismissals.
+ * A later comment hides a verdict from `latestReviews`, and `latestOpinionatedReviews` leaves out a dismissed one, so a push dismissal is read from its event.
+ * A dismissal that names the commit it came with is GitHub dismissing a stale review on a push; one dismissed by hand names none.
+ */
+export const AUTHORED_SEARCH_QUERY = `query GuidedReviewAuthored($query: String!) {
+  search(type: ISSUE, query: $query, first: ${REVIEW_SEARCH_SIZE}) {
+    issueCount
+    nodes {
+      ... on PullRequest {
+        ${LISTED_PULL_REQUEST_FIELDS}
+        reviewRequests(first: ${AUTHORED_REVIEWERS}) {
+          nodes { requestedReviewer { __typename ... on User { login } ... on Bot { login } ... on Mannequin { login } ... on Team { combinedSlug } } }
+        }
+        latestReviews(first: ${AUTHORED_REVIEWERS}) { nodes { state submittedAt author { login } commit { oid } } }
+        latestOpinionatedReviews(first: ${AUTHORED_REVIEWERS}) { nodes { state submittedAt author { login } } }
+        timelineItems(itemTypes: [REVIEW_DISMISSED_EVENT], last: ${AUTHORED_REVIEWERS}) {
+          nodes { ... on ReviewDismissedEvent { previousReviewState pullRequestCommit { id } review { submittedAt author { login } } } }
+        }
+      }
+    }
+  }
+}`;
+
+const ListedPullRequest = z.object({
+  number: z.number(),
+  url: z.string(),
+  title: z.string(),
+  isDraft: z.boolean(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+  headRefOid: z.string(),
+  additions: z.number(),
+  deletions: z.number(),
+  changedFiles: z.number(),
+  author: z.object({ login: z.string() }).nullable(),
+  statusCheckRollup: z.object({ state: z.enum(["EXPECTED", "ERROR", "FAILURE", "PENDING", "SUCCESS"]) }).nullable(),
+  reviews: z.object({ nodes: z.array(z.object({ viewerDidAuthor: z.boolean(), comments: z.object({ totalCount: z.number() }) })) }),
+});
+
+const ReviewState = z.enum(["PENDING", "COMMENTED", "APPROVED", "CHANGES_REQUESTED", "DISMISSED"]);
+
 const ReviewSearchResponse = z.object({
   data: z.object({
     viewer: z.object({ login: z.string() }),
     search: z.object({
       issueCount: z.number(),
       nodes: z.array(
-        z.object({
-          number: z.number(),
-          url: z.string(),
-          title: z.string(),
-          isDraft: z.boolean(),
-          createdAt: z.string(),
-          updatedAt: z.string(),
-          headRefOid: z.string(),
-          additions: z.number(),
-          deletions: z.number(),
-          changedFiles: z.number(),
-          author: z.object({ login: z.string() }).nullable(),
-          statusCheckRollup: z.object({ state: z.enum(["EXPECTED", "ERROR", "FAILURE", "PENDING", "SUCCESS"]) }).nullable(),
-          viewerLatestReview: z
-            .object({
-              state: z.enum(["PENDING", "COMMENTED", "APPROVED", "CHANGES_REQUESTED", "DISMISSED"]),
-              commit: z.object({ oid: z.string() }).nullable(),
-            })
-            .nullable(),
+        ListedPullRequest.extend({
+          viewerLatestReview: z.object({ state: ReviewState, commit: z.object({ oid: z.string() }).nullable() }).nullable(),
           viewerLatestReviewRequest: z
             .object({ requestedReviewer: z.object({ __typename: z.string(), combinedSlug: z.string().optional() }).nullable() })
             .nullable(),
-          reviews: z.object({ nodes: z.array(z.object({ viewerDidAuthor: z.boolean(), comments: z.object({ totalCount: z.number() }) })) }),
           timelineItems: z.object({
             nodes: z.array(z.object({ requestedReviewer: z.object({ __typename: z.string(), login: z.string().optional() }).nullable() })),
           }),
@@ -417,9 +447,45 @@ const ReviewSearchResponse = z.object({
   }),
 });
 
+const AuthoredPullRequest = ListedPullRequest.extend({
+  reviewRequests: z.object({
+    nodes: z.array(
+      z.object({ requestedReviewer: z.object({ login: z.string().optional(), combinedSlug: z.string().optional() }).nullable() }),
+    ),
+  }),
+  latestReviews: z.object({
+    nodes: z.array(
+      z.object({
+        state: ReviewState,
+        submittedAt: z.string().nullable(),
+        author: z.object({ login: z.string() }).nullable(),
+        commit: z.object({ oid: z.string() }).nullable(),
+      }),
+    ),
+  }),
+  latestOpinionatedReviews: z.object({
+    nodes: z.array(z.object({ state: ReviewState, submittedAt: z.string().nullable(), author: z.object({ login: z.string() }).nullable() })),
+  }),
+  timelineItems: z.object({
+    nodes: z.array(
+      z.object({
+        previousReviewState: z.string().optional(),
+        pullRequestCommit: z.object({ id: z.string() }).nullish(),
+        review: z.object({ submittedAt: z.string().nullable(), author: z.object({ login: z.string() }).nullable() }).nullish(),
+      }),
+    ),
+  }),
+});
+
+const AuthoredSearchResponse = z.object({
+  data: z.object({ search: z.object({ issueCount: z.number(), nodes: z.array(AuthoredPullRequest) }) }),
+});
+
+type ListedPullRequest = z.output<typeof ListedPullRequest>;
 type SearchedPullRequest = z.output<typeof ReviewSearchResponse>["data"]["search"]["nodes"][number];
+type AuthoredPullRequest = z.output<typeof AuthoredPullRequest>;
 
-const CI_STATES: Record<NonNullable<SearchedPullRequest["statusCheckRollup"]>["state"], CiState> = {
+const CI_STATES: Record<NonNullable<ListedPullRequest["statusCheckRollup"]>["state"], CiState> = {
   SUCCESS: "success",
   FAILURE: "failure",
   ERROR: "failure",
@@ -427,7 +493,7 @@ const CI_STATES: Record<NonNullable<SearchedPullRequest["statusCheckRollup"]>["s
   EXPECTED: "pending",
 };
 
-const REVIEWER_STATES: Record<NonNullable<SearchedPullRequest["viewerLatestReview"]>["state"], ReviewerState> = {
+const REVIEWER_STATES: Record<z.output<typeof ReviewState>, ReviewerState> = {
   PENDING: "requested",
   COMMENTED: "commented",
   APPROVED: "approved",
@@ -449,10 +515,71 @@ function wasAskedToReview(pr: SearchedPullRequest, login: string): boolean {
  * dismissed review is still one they wrote, and a pending one is not written yet.
  */
 function reviewRequestOf(pr: SearchedPullRequest, requested: boolean): ReviewRequest | null {
-  const ref = parsePullRequestUrl(pr.url);
-  if (ref === null) return null;
+  const listed = listedOf(pr);
+  if (listed === null) return null;
   const review = pr.viewerLatestReview?.state === "PENDING" ? null : pr.viewerLatestReview;
   const team = pr.viewerLatestReviewRequest?.requestedReviewer;
+  return {
+    ...listed,
+    state: requested || review === null ? "requested" : REVIEWER_STATES[review.state],
+    viaTeam: requested && team?.__typename === "Team" ? (team.combinedSlug ?? null) : null,
+    changedSinceReview: review === null ? null : requested || review.commit?.oid !== pr.headRefOid,
+  };
+}
+
+/**
+ * The viewer's own PR with where each reviewer stands: their latest approval or change request, else their approval GitHub dismissed on a push, else that they commented.
+ * A reviewer asked again is `requested`, as on GitLab, where asking again resets their state, unless they requested changes: a blocking review is never hidden.
+ * The author's own reviews are replies to threads, not reviews of their PR, so they are left out.
+ */
+function authoredOf(pr: AuthoredPullRequest): AuthoredChangeRequest | null {
+  const listed = listedOf(pr);
+  if (listed === null) return null;
+  const resets = new Map<string, string>();
+  for (const { previousReviewState, pullRequestCommit, review } of pr.timelineItems.nodes) {
+    if (previousReviewState !== "APPROVED" || !pullRequestCommit || !review?.submittedAt) continue;
+    const login = userOf(review.author).login;
+    const known = resets.get(login);
+    if (known === undefined || Date.parse(review.submittedAt) > Date.parse(known)) resets.set(login, review.submittedAt);
+  }
+  const opinions = new Map(pr.latestOpinionatedReviews.nodes.map((opinion) => [userOf(opinion.author).login, opinion]));
+  const reviews = pr.latestReviews.nodes.filter((review) => review.state !== "PENDING" && review.author?.login !== pr.author?.login);
+  const asked = new Set(
+    pr.reviewRequests.nodes.flatMap(({ requestedReviewer }) => {
+      const name = requestedReviewer?.combinedSlug ?? requestedReviewer?.login;
+      return name ? [name] : [];
+    }),
+  );
+  const states = new Map<string, ReviewerState>();
+  for (const review of reviews) {
+    const login = userOf(review.author).login;
+    states.set(login, standingOf(opinions.get(login), resets.get(login)) ?? REVIEWER_STATES[review.state]);
+  }
+  for (const name of asked) {
+    if (states.get(name) !== "changes-requested") states.set(name, "requested");
+  }
+  const reviewers = [...states].map(([name, state]) => ({ name, state }));
+  return {
+    ...listed,
+    status: reviewStatusOf(reviewers),
+    reviewers,
+    reviewedSinceLastPush: reviews.some(
+      (review) => review.state !== "DISMISSED" && states.get(userOf(review.author).login) !== "requested" && review.commit?.oid === pr.headRefOid,
+    ),
+    latestReviewAt: latestOf(reviews.flatMap((review) => (review.submittedAt === null ? [] : [review.submittedAt]))),
+  };
+}
+
+/** A reviewer's verdict, or the approval a push took from them when that came after it; null when they gave none. */
+function standingOf(opinion: AuthoredPullRequest["latestOpinionatedReviews"]["nodes"][number] | undefined, resetAt: string | undefined): ReviewerState | null {
+  const verdict = opinion?.state === "APPROVED" || opinion?.state === "CHANGES_REQUESTED" ? opinion : undefined;
+  if (resetAt !== undefined && (verdict?.submittedAt == null || Date.parse(resetAt) > Date.parse(verdict.submittedAt))) return "unapproved";
+  return verdict === undefined ? null : REVIEWER_STATES[verdict.state];
+}
+
+function listedOf(pr: ListedPullRequest): ListedChangeRequest | null {
+  const ref = parsePullRequestUrl(pr.url);
+  if (ref === null) return null;
   return {
     forge: "github",
     host: ref.host,
@@ -469,9 +596,6 @@ function reviewRequestOf(pr: SearchedPullRequest, requested: boolean): ReviewReq
     deletions: pr.deletions,
     fileCount: pr.changedFiles,
     ci: pr.statusCheckRollup ? CI_STATES[pr.statusCheckRollup.state] : null,
-    state: requested || review === null ? "requested" : REVIEWER_STATES[review.state],
-    viaTeam: requested && team?.__typename === "Team" ? (team.combinedSlug ?? null) : null,
-    changedSinceReview: review === null ? null : requested || review.commit?.oid !== pr.headRefOid,
     pendingDrafts: pr.reviews.nodes.find((pending) => pending.viewerDidAuthor)?.comments.totalCount ?? 0,
   };
 }
@@ -748,22 +872,36 @@ export function createGitHubForge(options: GitHubForgeOptions): Forge {
       });
     },
 
-    async listReviewRequests(): Promise<ReviewRequestHost[]> {
-      const search = (query: string) =>
-        gh.json(ReviewSearchResponse, ["api", "graphql", "--hostname", GITHUB_HOST, "--input", "-"], {
-          input: JSON.stringify({ query: REVIEW_SEARCH_QUERY, variables: { query } }),
+    async listChangeRequests(): Promise<ListedHost[]> {
+      const search = <T extends z.ZodType>(response: T, query: string, terms: string) =>
+        gh.json(response, ["api", "graphql", "--hostname", GITHUB_HOST, "--input", "-"], {
+          input: JSON.stringify({ query, variables: { query: terms } }),
         });
+      const hasMore = (...answers: { data: { search: { issueCount: number; nodes: unknown[] } } }[]) =>
+        answers.some(({ data }) => data.search.issueCount > data.search.nodes.length);
       try {
-        const [requested, reviewed] = await Promise.all([search(REVIEW_SEARCHES.requested), search(REVIEW_SEARCHES.reviewed)]);
-        const requests = [
+        const [requested, reviewed, authored] = await Promise.all([
+          search(ReviewSearchResponse, REVIEW_SEARCH_QUERY, REVIEW_SEARCHES.requested),
+          search(ReviewSearchResponse, REVIEW_SEARCH_QUERY, REVIEW_SEARCHES.reviewed),
+          search(AuthoredSearchResponse, AUTHORED_SEARCH_QUERY, REVIEW_SEARCHES.authored),
+        ]);
+        const assigned = [
           ...requested.data.search.nodes.map((pr) => reviewRequestOf(pr, true)),
           ...reviewed.data.search.nodes.filter((pr) => wasAskedToReview(pr, reviewed.data.viewer.login)).map((pr) => reviewRequestOf(pr, false)),
         ].filter((request) => request !== null);
-        const truncated = [requested, reviewed].some(({ data }) => data.search.issueCount > data.search.nodes.length);
-        return [{ forge: "github", host: GITHUB_HOST, requests, truncated, error: null }];
+        return [
+          {
+            forge: "github",
+            host: GITHUB_HOST,
+            assigned,
+            authored: authored.data.search.nodes.map(authoredOf).filter((request) => request !== null),
+            truncated: { assigned: hasMore(requested, reviewed), authored: hasMore(authored) },
+            error: null,
+          },
+        ];
       } catch (error) {
         if (!(error instanceof ForgeError)) throw error;
-        return [{ forge: "github", host: GITHUB_HOST, requests: [], truncated: false, error: error.message }];
+        return [unlistedHost("github", GITHUB_HOST, error.message)];
       }
     },
   };
diff --git a/plugins/guided-review/server/forge/gitlab.test.ts b/plugins/guided-review/server/forge/gitlab.test.ts
index 4b16cef..533bb12 100644
--- a/plugins/guided-review/server/forge/gitlab.test.ts
+++ b/plugins/guided-review/server/forge/gitlab.test.ts
@@ -1182,7 +1182,7 @@ test("reads every host glab reports, logged in or not, and why glab cannot use o
 test("lists the open MRs the viewer reviews on each host glab is logged in to, after checking its version", async () => {
   const { forge, run } = forgeReplaying(LIST_REVIEWS);
 
-  const hosts = await forge.listReviewRequests();
+  const hosts = await forge.listChangeRequests();
 
   assert.deepEqual(
     run.calls.map((call) => call.args),
@@ -1195,8 +1195,8 @@ test("lists the open MRs the viewer reviews on each host glab is logged in to, a
   assert.equal(hosts.length, 1);
   const [host] = hosts;
   assert.equal(host?.error, null);
-  assert.equal(host?.truncated, false);
-  assert.deepEqual(host?.requests[0], {
+  assert.deepEqual(host?.truncated, { assigned: false, authored: false });
+  assert.deepEqual(host?.assigned[0], {
     forge: "gitlab",
     host: "gitlab.com",
     project: "example-group/service",
@@ -1222,8 +1222,8 @@ test("lists the open MRs the viewer reviews on each host glab is logged in to, a
 test("an MR reads by the viewer's own reviewer record, changed when the head commit is newer than it", async () => {
   const { forge } = forgeReplaying(LIST_REVIEWS);
 
-  const [host] = await forge.listReviewRequests();
-  const summary = host?.requests.map(({ number, state, changedSinceReview, ci, author, isDraft }) => ({ number, state, changedSinceReview, ci, author, isDraft }));
+  const [host] = await forge.listChangeRequests();
+  const summary = host?.assigned.map(({ number, state, changedSinceReview, ci, author, isDraft }) => ({ number, state, changedSinceReview, ci, author, isDraft }));
 
   assert.deepEqual(summary, [
     { number: 12, state: "requested", changedSinceReview: null, ci: "failure", author: "author", isDraft: false },
@@ -1234,50 +1234,179 @@ test("an MR reads by the viewer's own reviewer record, changed when the head com
   ]);
 });
 
+test("lists the viewer's own open MRs, drafts included, with where their reviewers stand, in the same query as the MRs they review", async () => {
+  const { forge, run } = forgeReplaying(LIST_REVIEWS);
+
+  const [host] = await forge.listChangeRequests();
+
+  assert.equal(run.calls.filter((call) => call.args[1] === "graphql").length, 1);
+  assert.match(REVIEW_LIST_QUERY, /authoredMergeRequests\(state: opened, first: 100, sort: UPDATED_DESC\)/);
+  assert.deepEqual(host?.authored, [
+    {
+      forge: "gitlab",
+      host: "gitlab.com",
+      project: "example-group/service",
+      number: 15,
+      url: "https://gitlab.com/example-group/service/-/merge_requests/15",
+      title: "Stream large uploads to storage",
+      author: "reviewer",
+      isDraft: false,
+      createdAt: "2026-10-01T08:00:00Z",
+      updatedAt: "2026-10-05T09:30:00Z",
+      headSha: "6".repeat(40),
+      additions: 210,
+      deletions: 44,
+      fileCount: 7,
+      ci: "success",
+      pendingDrafts: null,
+      status: "changes-requested",
+      reviewers: [
+        { name: "maintainer", state: "approved" },
+        { name: "designer", state: "changes-requested" },
+        { name: "backend-lead", state: "requested" },
+        { name: "passer-by", state: "approved" },
+      ],
+      reviewedSinceLastPush: true,
+      latestReviewAt: "2026-10-05T10:15:00Z",
+    },
+    {
+      forge: "gitlab",
+      host: "gitlab.com",
+      project: "example-group/sub/web",
+      number: 43,
+      url: "https://gitlab.com/example-group/sub/web/-/merge_requests/43",
+      title: "Draft: Resume an interrupted upload",
+      author: "reviewer",
+      isDraft: true,
+      createdAt: "2026-10-02T08:00:00Z",
+      updatedAt: "2026-10-02T08:10:00Z",
+      headSha: "7".repeat(40),
+      additions: 0,
+      deletions: 0,
+      fileCount: 0,
+      ci: null,
+      pendingDrafts: null,
+      status: "unreviewed",
+      reviewers: [],
+      reviewedSinceLastPush: false,
+      latestReviewAt: null,
+    },
+  ]);
+});
+
+type Interaction = { reviewState: string; approved: boolean; updatedAt: string };
+
+/** The authored MR !15 as GitLab lists it, with these reviewer records and approvers in place of the fixture's. */
+async function authored15(mr: { reviewers?: Record<string, Interaction>; approvedBy?: string[]; pushedAt?: string | null }) {
+  const answer = JSON.parse(fixture("review-list.json"));
+  const node = answer.data.currentUser.authoredMergeRequests.nodes[0];
+  node.reviewers.nodes = Object.entries(mr.reviewers ?? {}).map(([username, mergeRequestInteraction]) => ({ username, mergeRequestInteraction }));
+  node.approvedBy.nodes = (mr.approvedBy ?? []).map((username) => ({ username }));
+  if (mr.pushedAt !== undefined) node.mergeRequestDiffs.nodes = mr.pushedAt === null ? [] : [{ createdAt: mr.pushedAt }];
+  const { forge } = forgeReplaying([AUTH_STATUS_ALL, version("19.5.0-pre"), { stdout: JSON.stringify(answer) }]);
+  return (await forge.listChangeRequests())[0]!.authored[0]!;
+}
+
+/** The fixture's head commit of !15 is dated 2026-10-05T09:00 and was pushed at 09:20. */
+const BEFORE_HEAD = "2026-10-04T12:00:00Z";
+const BEFORE_PUSH = "2026-10-05T09:10:00Z";
+const AFTER_HEAD = "2026-10-05T11:00:00Z";
+const interaction = (reviewState: string, updatedAt: string): Interaction => ({ reviewState, approved: reviewState === "APPROVED", updatedAt });
+
+test("an approval GitLab took back reads as an approval reset, and one still standing beats it", async () => {
+  const reset = await authored15({ reviewers: { maintainer: interaction("UNAPPROVED", AFTER_HEAD) } });
+  const standing = await authored15({ reviewers: { maintainer: interaction("UNAPPROVED", AFTER_HEAD), lead: interaction("APPROVED", AFTER_HEAD) }, approvedBy: ["lead"] });
+
+  assert.equal(reset.status, "approval-reset");
+  assert.deepEqual(reset.reviewers, [{ name: "maintainer", state: "unapproved" }]);
+  assert.equal(reset.reviewedSinceLastPush, false, "a reset is no review");
+  assert.equal(reset.latestReviewAt, null);
+  assert.equal(standing.status, "approved");
+});
+
+test("reviewers asked and none answered is waiting, and a review without a verdict is commented", async () => {
+  const waiting = await authored15({ reviewers: { maintainer: interaction("UNREVIEWED", AFTER_HEAD), designer: interaction("REVIEW_STARTED", AFTER_HEAD) } });
+  const commented = await authored15({ reviewers: { maintainer: interaction("UNREVIEWED", AFTER_HEAD), designer: interaction("REVIEWED", BEFORE_HEAD) } });
+
+  assert.equal(waiting.status, "waiting");
+  assert.equal(waiting.reviewedSinceLastPush, false);
+  assert.equal(waiting.latestReviewAt, null);
+  assert.equal(commented.status, "commented");
+  assert.equal(commented.reviewedSinceLastPush, false, "the review is older than the head");
+  assert.equal(commented.latestReviewAt, BEFORE_HEAD);
+});
+
+test("the author's own reviewer record and approval are not a review of their MR", async () => {
+  const own = await authored15({ reviewers: { Reviewer: interaction("APPROVED", AFTER_HEAD) }, approvedBy: ["reviewer"] });
+
+  assert.equal(own.status, "unreviewed");
+  assert.deepEqual(own.reviewers, []);
+  assert.equal(own.latestReviewAt, null);
+});
+
+test("a review between the head commit and its push is not one since the push", async () => {
+  const beforePush = await authored15({ reviewers: { designer: interaction("REQUESTED_CHANGES", BEFORE_PUSH) } });
+
+  assert.equal(beforePush.reviewedSinceLastPush, false);
+});
+
+test("whether a review came after the push is unknown when GitLab gives no version of the head", async () => {
+  const undated = await authored15({ reviewers: { designer: interaction("REQUESTED_CHANGES", AFTER_HEAD) }, pushedAt: null });
+
+  assert.equal(undated.status, "changes-requested");
+  assert.equal(undated.reviewedSinceLastPush, null);
+  assert.equal(undated.latestReviewAt, AFTER_HEAD);
+});
+
 test("a host glab is not logged in to, or one older than 19.2, comes back with its error and the others listed", async () => {
   const report = { exitCode: 1, stderr: fixture("auth-status-all-unreachable.stderr") + fixture("auth-status-all.stderr") };
   const { forge } = forgeReplaying([report, version("19.5.0-pre"), { stdout: fixture("review-list.json") }]);
 
-  const hosts = await forge.listReviewRequests();
+  const hosts = await forge.listChangeRequests();
 
   assert.deepEqual(
-    hosts.map(({ host, error, requests }) => ({ host, error, count: requests.length })),
+    hosts.map(({ host, error, assigned, authored }) => ({ host, error, counts: [assigned.length, authored.length] })),
     [
       {
         host: "gitlab.example.invalid",
         error:
           'glab is not logged in to gitlab.example.invalid (API call failed: Get "https://gitlab.example.invalid/api/v4/user": dial tcp: lookup gitlab.example.invalid: no such host). Run `glab auth login --hostname gitlab.example.invalid` on the daemon\'s host.',
-        count: 0,
+        counts: [0, 0],
       },
-      { host: "gitlab.com", error: null, count: 5 },
+      { host: "gitlab.com", error: null, counts: [5, 2] },
     ],
   );
 
   const { forge: old } = forgeReplaying([AUTH_STATUS_ALL, version("18.11.2-ee")]);
-  assert.deepEqual(await old.listReviewRequests(), [
-    { forge: "gitlab", host: "gitlab.com", requests: [], truncated: false, error: "gitlab.com runs GitLab 18.11.2-ee; listing your reviews needs 19.2 or newer." },
+  assert.deepEqual(await old.listChangeRequests(), [
+    { forge: "gitlab", host: "gitlab.com", assigned: [], authored: [], truncated: { assigned: false, authored: false }, error: "gitlab.com runs GitLab 18.11.2-ee; listing your reviews needs 19.2 or newer." },
   ]);
 });
 
-test("a GraphQL answer with errors and no user is the host's error, and more MRs than a page mark it truncated", async () => {
+test("a GraphQL answer with errors and no user is the host's error, and more MRs than a page mark that list truncated", async () => {
   const failed = JSON.stringify({ data: { currentUser: null }, errors: [{ message: "Query has complexity of 301, which exceeds max complexity of 250" }] });
   const { forge } = forgeReplaying([AUTH_STATUS_ALL, version("19.5.0-pre"), { stdout: failed }]);
   assert.equal(
-    (await forge.listReviewRequests())[0]?.error,
+    (await forge.listChangeRequests())[0]?.error,
     "GitLab on gitlab.com did not list your reviews: Query has complexity of 301, which exceeds max complexity of 250.",
   );
 
   const more = JSON.parse(fixture("review-list.json"));
   more.data.currentUser.reviewRequestedMergeRequests.pageInfo.hasNextPage = true;
   const { forge: paged } = forgeReplaying([AUTH_STATUS_ALL, version("19.5.0-pre"), { stdout: JSON.stringify(more) }]);
-  assert.equal((await paged.listReviewRequests())[0]?.truncated, true);
+  assert.deepEqual((await paged.listChangeRequests())[0]?.truncated, { assigned: true, authored: false });
+
+  const mine = JSON.parse(fixture("review-list.json"));
+  mine.data.currentUser.authoredMergeRequests.pageInfo.hasNextPage = true;
+  const { forge: pagedMine } = forgeReplaying([AUTH_STATUS_ALL, version("19.5.0-pre"), { stdout: JSON.stringify(mine) }]);
+  assert.deepEqual((await pagedMine.listChangeRequests())[0]?.truncated, { assigned: false, authored: true });
 });
 
 test("a host listed as logged in is not checked again before reading an MR on it", async () => {
   const head = { stdout: JSON.stringify({ state: "opened", description: null, sha: "a".repeat(40), diff_refs: { head_sha: "a".repeat(40) } }) };
   const { forge, run } = forgeReplaying([...LIST_REVIEWS, { stdout: fixture("project.json") }, head]);
 
-  await forge.listReviewRequests();
+  await forge.listChangeRequests();
   run.calls.length = 0;
 
   assert.deepEqual(await forge.fetchHead(MR_3931), { headSha: "a".repeat(40), state: "open", description: "" });
diff --git a/plugins/guided-review/server/forge/gitlab.ts b/plugins/guided-review/server/forge/gitlab.ts
index f50401c..ae0f735 100644
--- a/plugins/guided-review/server/forge/gitlab.ts
+++ b/plugins/guided-review/server/forge/gitlab.ts
@@ -3,10 +3,10 @@ import { z } from "zod";
 import type { Draft, DraftLocation, LineRef } from "../../shared/drafts.ts";
 import type { CommandRunner } from "../command-runner.ts";
 import type { Verdict } from "../../shared/submit.ts";
-import type { CiState, ReviewerState, ReviewRequest, ReviewRequestHost } from "../../shared/inbox.ts";
+import type { AuthoredChangeRequest, CiState, ListedChangeRequest, ListedHost, ReviewerState, ReviewRequest } from "../../shared/inbox.ts";
 import { createCli, type Cli } from "./cli.ts";
 import { GITHUB_HOST } from "./github.ts";
-import { CLONE_TIMEOUT_MS, COMMIT_READS_AT_ONCE, mapAtMost, MAX_BRANCH_CHANGE_REQUESTS, MAX_COMMITS, MAX_LINKED_ISSUES, userOf } from "./common.ts";
+import { CLONE_TIMEOUT_MS, COMMIT_READS_AT_ONCE, mapAtMost, MAX_BRANCH_CHANGE_REQUESTS, MAX_COMMITS, MAX_LINKED_ISSUES, latestOf, reviewStatusOf, unlistedHost, userOf } from "./common.ts";
 import { SubmitSteps } from "./submit-steps.ts";
 import {
   commitsSinceIn,
@@ -201,8 +201,21 @@ function isAtLeast(version: string, [needMajor, needMinor]: readonly [number, nu
 const REVIEW_LIST_SIZE = 100;
 
 /**
- * The open MRs the viewer is a reviewer of, with their own reviewer record among the MR's reviewers,
- * since GitLab has no field for the viewer's alone. The first commit is the head, newest first.
+ * What either list asks of an MR.
+ * The first commit is the head, newest first.
+ */
+const LISTED_MERGE_REQUEST_FIELDS = `webUrl title draft createdAt updatedAt diffHeadSha
+        author { username }
+        diffStatsSummary { additions deletions fileCount }
+        headPipeline { status }
+        commits(first: 1) { nodes { sha committedDate } }`;
+
+const REVIEWER_FIELDS = "reviewers { nodes { username mergeRequestInteraction { reviewState approved updatedAt } } }";
+
+/**
+ * The open MRs the viewer is a reviewer of, with their own reviewer record among the MR's reviewers, since GitLab has no field for the viewer's alone.
+ * The open MRs the viewer authored, with every reviewer's record and whoever approved without being one.
+ * Both lists are one query, so a host fails for both at once, and the query has to stay under the complexity GitLab allows a signed-in user.
  */
 export const REVIEW_LIST_QUERY = `query GuidedReviewInbox {
   currentUser {
@@ -210,12 +223,17 @@ export const REVIEW_LIST_QUERY = `query GuidedReviewInbox {
     reviewRequestedMergeRequests(state: opened, first: ${REVIEW_LIST_SIZE}, sort: UPDATED_DESC) {
       pageInfo { hasNextPage }
       nodes {
-        webUrl title draft createdAt updatedAt diffHeadSha
-        author { username }
-        diffStatsSummary { additions deletions fileCount }
-        headPipeline { status }
-        commits(first: 1) { nodes { sha committedDate } }
-        reviewers { nodes { username mergeRequestInteraction { reviewState approved updatedAt } } }
+        ${LISTED_MERGE_REQUEST_FIELDS}
+        ${REVIEWER_FIELDS}
+      }
+    }
+    authoredMergeRequests(state: opened, first: ${REVIEW_LIST_SIZE}, sort: UPDATED_DESC) {
+      pageInfo { hasNextPage }
+      nodes {
+        ${LISTED_MERGE_REQUEST_FIELDS}
+        ${REVIEWER_FIELDS}
+        approvedBy { nodes { username } }
+        mergeRequestDiffs(first: 1) { nodes { createdAt } }
       }
     }
   }
@@ -223,6 +241,42 @@ export const REVIEW_LIST_QUERY = `query GuidedReviewInbox {
 
 const GITLAB_REVIEW_STATES = ["UNREVIEWED", "REVIEW_STARTED", "REVIEWED", "REQUESTED_CHANGES", "APPROVED", "UNAPPROVED"] as const;
 
+const ListedMergeRequest = z.object({
+  webUrl: z.string(),
+  title: z.string(),
+  draft: z.boolean(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+  diffHeadSha: z.string().nullable(),
+  author: z.object({ username: z.string() }).nullable(),
+  diffStatsSummary: z.object({ additions: z.number(), deletions: z.number(), fileCount: z.number() }).nullable(),
+  headPipeline: z.object({ status: z.string() }).nullable(),
+  commits: z.object({ nodes: z.array(z.object({ sha: z.string(), committedDate: z.string().nullable() })) }).nullable(),
+});
+
+const ReviewedMergeRequest = ListedMergeRequest.extend({
+  reviewers: z.object({
+    nodes: z.array(
+      z.object({
+        username: z.string(),
+        mergeRequestInteraction: z
+          .object({ reviewState: z.enum(GITLAB_REVIEW_STATES).nullable(), approved: z.boolean(), updatedAt: z.string().nullable() })
+          .nullable(),
+      }),
+    ),
+  }),
+});
+
+const AuthoredMergeRequest = ReviewedMergeRequest.extend({
+  approvedBy: z.object({ nodes: z.array(z.object({ username: z.string() })) }),
+  /** The MR's diff versions, newest first, so the first is the head's push. */
+  mergeRequestDiffs: z.object({ nodes: z.array(z.object({ createdAt: z.string() })) }).nullable(),
+});
+
+function pageOf<Node extends z.ZodType>(node: Node) {
+  return z.object({ pageInfo: z.object({ hasNextPage: z.boolean() }), nodes: z.array(node) });
+}
+
 /** GraphQL reports a failure as HTTP 200 with `errors`, and `data` null where it could not answer. */
 const ReviewListResponse = z.object({
   data: z
@@ -230,33 +284,8 @@ const ReviewListResponse = z.object({
       currentUser: z
         .object({
           username: z.string(),
-          reviewRequestedMergeRequests: z.object({
-            pageInfo: z.object({ hasNextPage: z.boolean() }),
-            nodes: z.array(
-              z.object({
-                webUrl: z.string(),
-                title: z.string(),
-                draft: z.boolean(),
-                createdAt: z.string(),
-                updatedAt: z.string(),
-                diffHeadSha: z.string().nullable(),
-                author: z.object({ username: z.string() }).nullable(),
-                diffStatsSummary: z.object({ additions: z.number(), deletions: z.number(), fileCount: z.number() }).nullable(),
-                headPipeline: z.object({ status: z.string() }).nullable(),
-                commits: z.object({ nodes: z.array(z.object({ sha: z.string(), committedDate: z.string().nullable() })) }).nullable(),
-                reviewers: z.object({
-                  nodes: z.array(
-                    z.object({
-                      username: z.string(),
-                      mergeRequestInteraction: z
-                        .object({ reviewState: z.enum(GITLAB_REVIEW_STATES).nullable(), approved: z.boolean(), updatedAt: z.string().nullable() })
-                        .nullable(),
-                    }),
-                  ),
-                }),
-              }),
-            ),
-          }),
+          reviewRequestedMergeRequests: pageOf(ReviewedMergeRequest),
+          authoredMergeRequests: pageOf(AuthoredMergeRequest),
         })
         .nullable(),
     })
@@ -264,7 +293,10 @@ const ReviewListResponse = z.object({
   errors: z.array(z.object({ message: z.string() })).nullish(),
 });
 
-type ListedMergeRequest = NonNullable<NonNullable<z.output<typeof ReviewListResponse>["data"]>["currentUser"]>["reviewRequestedMergeRequests"]["nodes"][number];
+type ListedMergeRequest = z.output<typeof ListedMergeRequest>;
+type ReviewedMergeRequest = z.output<typeof ReviewedMergeRequest>;
+type AuthoredMergeRequest = z.output<typeof AuthoredMergeRequest>;
+type ReviewerRecord = ReviewedMergeRequest["reviewers"]["nodes"][number];
 
 const LISTED_STATES: Record<(typeof GITLAB_REVIEW_STATES)[number], ReviewerState> = {
   UNREVIEWED: "requested",
@@ -293,18 +325,62 @@ const CI_STATES: Record<string, CiState> = {
  * the commit a review was of, so a review older than the head commit counts as changed since; one
  * GitLab took an approval back from was pushed to, and one still unreviewed may have been asked again.
  */
-function reviewRequestOf(mr: ListedMergeRequest, viewer: string): ReviewRequest | null {
-  const ref = parseMergeRequestUrl(mr.webUrl);
-  if (ref === null) return null;
-  const own = mr.reviewers.nodes.find((reviewer) => reviewer.username.toLowerCase() === viewer.toLowerCase())?.mergeRequestInteraction;
+function reviewRequestOf(mr: ReviewedMergeRequest, viewer: string): ReviewRequest | null {
+  const listed = listedOf(mr);
+  if (listed === null) return null;
+  const own = mr.reviewers.nodes.find((reviewer) => sameUser(reviewer.username, viewer))?.mergeRequestInteraction;
   const reviewState = own?.reviewState ?? "UNREVIEWED";
   const head = mr.commits?.nodes[0];
-  const state = own?.approved ? "approved" : LISTED_STATES[reviewState];
+  const state = reviewerStateOf(own ?? null);
   let changedSinceReview: boolean | null = null;
   if (reviewState === "UNAPPROVED") changedSinceReview = true;
   else if (state !== "requested" && own?.updatedAt && head?.committedDate) {
     changedSinceReview = Date.parse(head.committedDate) > Date.parse(own.updatedAt);
   }
+  return { ...listed, state, viaTeam: null, changedSinceReview };
+}
+
+function reviewerStateOf(interaction: ReviewerRecord["mergeRequestInteraction"]): ReviewerState {
+  return interaction?.approved ? "approved" : LISTED_STATES[interaction?.reviewState ?? "UNREVIEWED"];
+}
+
+function sameUser(a: string, b: string): boolean {
+  return a.toLowerCase() === b.toLowerCase();
+}
+
+/**
+ * The viewer's own MR with where each reviewer stands, and anyone who approved without being asked.
+ * GitLab gives the same state to an approval taken back by a push and one its reviewer revoked, so both read as an approval reset.
+ * It keeps no record of the commit a review was of, so a review after the head's push counts as one since the push.
+ */
+function authoredOf(mr: AuthoredMergeRequest): AuthoredChangeRequest | null {
+  const listed = listedOf(mr);
+  if (listed === null) return null;
+  const others = mr.reviewers.nodes.filter((reviewer) => !sameUser(reviewer.username, listed.author));
+  const reviewers = others.map((reviewer) => ({ name: reviewer.username, state: reviewerStateOf(reviewer.mergeRequestInteraction) }));
+  for (const { username } of mr.approvedBy.nodes) {
+    if (!sameUser(username, listed.author) && !reviewers.some((reviewer) => sameUser(reviewer.name, username))) reviewers.push({ name: username, state: "approved" });
+  }
+  const reviewedAt = others.flatMap((reviewer) => {
+    const at = reviewer.mergeRequestInteraction?.updatedAt;
+    return at && REVIEWED_STATES.has(reviewerStateOf(reviewer.mergeRequestInteraction)) ? [at] : [];
+  });
+  const pushedAt = mr.mergeRequestDiffs?.nodes[0]?.createdAt;
+  return {
+    ...listed,
+    status: reviewStatusOf(reviewers),
+    reviewers,
+    reviewedSinceLastPush: reviewedAt.length === 0 ? false : pushedAt ? reviewedAt.some((at) => Date.parse(at) > Date.parse(pushedAt)) : null,
+    latestReviewAt: latestOf(reviewedAt),
+  };
+}
+
+/** The states a reviewer reaches by reviewing, rather than by being asked or by GitLab taking an approval back. */
+const REVIEWED_STATES: ReadonlySet<ReviewerState> = new Set(["commented", "changes-requested", "approved"]);
+
+function listedOf(mr: ListedMergeRequest): ListedChangeRequest | null {
+  const ref = parseMergeRequestUrl(mr.webUrl);
+  if (ref === null) return null;
   return {
     forge: "gitlab",
     host: ref.host,
@@ -316,14 +392,11 @@ function reviewRequestOf(mr: ListedMergeRequest, viewer: string): ReviewRequest
     isDraft: mr.draft,
     createdAt: mr.createdAt,
     updatedAt: mr.updatedAt,
-    headSha: mr.diffHeadSha ?? head?.sha ?? "",
+    headSha: mr.diffHeadSha ?? mr.commits?.nodes[0]?.sha ?? "",
     additions: mr.diffStatsSummary?.additions ?? 0,
     deletions: mr.diffStatsSummary?.deletions ?? 0,
     fileCount: mr.diffStatsSummary?.fileCount ?? 0,
     ci: (mr.headPipeline && CI_STATES[mr.headPipeline.status]) ?? null,
-    state,
-    viaTeam: null,
-    changedSinceReview,
     pendingDrafts: null,
   };
 }
@@ -432,7 +505,7 @@ export function createGitLabForge(options: GitLabForgeOptions): Forge {
     );
   };
 
-  const reviewRequestsOn = async (host: string): Promise<Omit<ReviewRequestHost, "error">> => {
+  const listingOn = async (host: string): Promise<Omit<ListedHost, "error">> => {
     const { version } = await glab.json(VersionResponse, ["api", "--hostname", host, "version"]);
     if (!isAtLeast(version, REVIEW_LIST_VERSION)) {
       throw new ForgeError(`${host} runs GitLab ${version}; listing your reviews needs ${REVIEW_LIST_VERSION.join(".")} or newer.`);
@@ -442,12 +515,13 @@ export function createGitLabForge(options: GitLabForgeOptions): Forge {
     if (!user) {
       throw new ForgeError(`GitLab on ${host} did not list your reviews: ${response.errors?.[0]?.message ?? "no current user"}.`);
     }
-    const { nodes, pageInfo } = user.reviewRequestedMergeRequests;
+    const { reviewRequestedMergeRequests: assigned, authoredMergeRequests: authored } = user;
     return {
       forge: "gitlab",
       host,
-      requests: nodes.map((mr) => reviewRequestOf(mr, user.username)).filter((request) => request !== null),
-      truncated: pageInfo.hasNextPage,
+      assigned: assigned.nodes.map((mr) => reviewRequestOf(mr, user.username)).filter((request) => request !== null),
+      authored: authored.nodes.map(authoredOf).filter((request) => request !== null),
+      truncated: { assigned: assigned.pageInfo.hasNextPage, authored: authored.pageInfo.hasNextPage },
     };
   };
 
@@ -829,21 +903,20 @@ export function createGitLabForge(options: GitLabForgeOptions): Forge {
       }
     },
 
-    async listReviewRequests(): Promise<ReviewRequestHost[]> {
+    async listChangeRequests(): Promise<ListedHost[]> {
       const statuses = parseAuthStatus(await glab.report(["auth", "status", "--all"]));
       return Promise.all(
-        statuses.map(async ({ host, loggedIn, problem }): Promise<ReviewRequestHost> => {
-          const listed = { forge: "gitlab" as const, host, requests: [], truncated: false };
+        statuses.map(async ({ host, loggedIn, problem }): Promise<ListedHost> => {
           if (!loggedIn) {
             const reason = problem === null ? "" : ` (${problem})`;
-            return { ...listed, error: `glab is not logged in to ${host}${reason}. Run \`glab auth login --hostname ${host}\` on the daemon's host.` };
+            return unlistedHost("gitlab", host, `glab is not logged in to ${host}${reason}. Run \`glab auth login --hostname ${host}\` on the daemon's host.`);
           }
           hosts.set(host, Promise.resolve());
           try {
-            return { ...(await reviewRequestsOn(host)), error: null };
+            return { ...(await listingOn(host)), error: null };
           } catch (error) {
             if (!(error instanceof ForgeError)) throw error;
-            return { ...listed, error: error.message };
+            return unlistedHost("gitlab", host, error.message);
           }
         }),
       );
diff --git a/plugins/guided-review/server/forge/port.ts b/plugins/guided-review/server/forge/port.ts
index 245ecbc..1bf69e3 100644
--- a/plugins/guided-review/server/forge/port.ts
+++ b/plugins/guided-review/server/forge/port.ts
@@ -1,6 +1,6 @@
 import type { DiffLine } from "../../shared/diff.ts";
 import type { Draft } from "../../shared/drafts.ts";
-import type { ReviewRequestHost } from "../../shared/inbox.ts";
+import type { ListedHost } from "../../shared/inbox.ts";
 import type { SubmitStep, Verdict } from "../../shared/submit.ts";
 
 /**
@@ -95,10 +95,10 @@ export interface Forge {
   discardReview(ref: ChangeRequestRef): Promise<void>;
 
   /**
-   * The open change requests the current user is a reviewer of, on every host of this forge the CLI
-   * is logged in to. A host that cannot be listed comes back with its error rather than throwing.
+   * The open change requests the current user is a reviewer of, and those they authored, on every host of this forge the CLI is logged in to.
+   * A host that cannot be listed comes back with its error rather than throwing.
    */
-  listReviewRequests(): Promise<ReviewRequestHost[]>;
+  listChangeRequests(): Promise<ListedHost[]>;
 }
 
 /**
diff --git a/plugins/guided-review/server/inbox-check-offs.ts b/plugins/guided-review/server/inbox-check-offs.ts
index c9fa6ba..fe2f278 100644
--- a/plugins/guided-review/server/inbox-check-offs.ts
+++ b/plugins/guided-review/server/inbox-check-offs.ts
@@ -1,18 +1,32 @@
 import path from "node:path";
-import { CheckOffSchema, type CheckOff, type ReviewerState, type ReviewRequest, type ReviewRequestHost } from "../shared/inbox.ts";
+import type { z } from "zod";
+import {
+  AuthoredCheckOffSchema,
+  CheckOffSchema,
+  type AuthoredChangeRequest,
+  type AuthoredCheckOff,
+  type CheckOff,
+  type CheckOffChange,
+  type ListedChangeRequest,
+  type ListedHost,
+  type ReviewerState,
+  type ReviewRequest,
+} from "../shared/inbox.ts";
+import type { InboxTab } from "../shared/inbox-preferences.ts";
+import { byTab } from "./inbox-tabs.ts";
 import { readJson, writeJson } from "./json-file.ts";
 import { oneAtATimePer } from "./one-at-a-time.ts";
 
 const FILE = "inbox-check-offs.json";
 
-/** Check-offs by the change request's URL. */
-type CheckOffs = Record<string, CheckOff>;
+/** Each tab's check-offs by the change request's URL, kept apart so a check-off on one tab leaves the other alone. */
+type CheckOffs = { assigned: Record<string, CheckOff>; authored: Record<string, AuthoredCheckOff> };
 
 /** The states only the other side brings about: being asked again, or an approval taken back. */
 const RETURNING_STATES: readonly ReviewerState[] = ["requested", "unapproved"];
 
 /**
- * What the reviewer checked off the review list, which the forge knows nothing of.
+ * What the viewer checked off each tab of the review list, which the forge knows nothing of.
  * A check-off holds only until the change request moves on, so each listing is followed to drop those that came back or left the list.
  */
 export class InboxCheckOffsFile {
@@ -23,27 +37,25 @@ export class InboxCheckOffsFile {
     this.#file = path.join(dataDirectory, FILE);
   }
 
-  async set(url: string, checkOff: CheckOff | null): Promise<void> {
+  async set({ tab, url, checkOff }: CheckOffChange): Promise<void> {
     await this.#change((checkOffs) => {
-      const { [url]: _, ...rest } = checkOffs;
-      return checkOff === null ? rest : { ...rest, [url]: checkOff };
+      const { [url]: _, ...rest } = checkOffs[tab];
+      return { ...checkOffs, [tab]: checkOff === null ? rest : { ...rest, [url]: checkOff } };
     });
   }
 
-  /** Follows a listing of every host, and answers the URLs still checked off. */
-  async follow(hosts: readonly ReviewRequestHost[]): Promise<Set<string>> {
-    return new Set(Object.keys(await this.#change((checkOffs) => followListing(checkOffs, hosts))));
+  /** Follows a listing of every host, and answers the URLs still checked off on each tab. */
+  async follow(hosts: readonly ListedHost[]): Promise<Record<InboxTab, Set<string>>> {
+    const followed = await this.#change((checkOffs) => ({
+      assigned: followListing(checkOffs.assigned, hosts, "assigned", (host) => host.assigned, assignedStillOff),
+      authored: followListing(checkOffs.authored, hosts, "authored", (host) => host.authored, authoredStillOff),
+    }));
+    return { assigned: new Set(Object.keys(followed.assigned)), authored: new Set(Object.keys(followed.authored)) };
   }
 
   async #read(): Promise<CheckOffs> {
-    const stored = await readJson<unknown>(this.#file);
-    if (typeof stored !== "object" || stored === null) return {};
-    const checkOffs: CheckOffs = {};
-    for (const [url, value] of Object.entries(stored)) {
-      const parsed = CheckOffSchema.safeParse(value);
-      if (parsed.success) checkOffs[url] = parsed.data;
-    }
-    return checkOffs;
+    const stored = byTab(await readJson<unknown>(this.#file));
+    return { assigned: byUrl(stored.assigned, CheckOffSchema), authored: byUrl(stored.authored, AuthoredCheckOffSchema) };
   }
 
   async #change(update: (checkOffs: CheckOffs) => CheckOffs): Promise<CheckOffs> {
@@ -57,27 +69,54 @@ export class InboxCheckOffsFile {
 }
 
 /**
- * Drops the check-offs whose change request came back, and those a host listed in full no longer has.
- * The rest keep the state the reviewer is now in, so one they moved on themselves, by commenting, still comes back when they are asked again.
+ * Follows one tab's check-offs through a listing: `stillOff` answers what a listed one holds as, or null once it came back.
+ * Those a host listed in full no longer has are dropped; those on a host that failed or has more than it listed are kept.
  */
-function followListing(checkOffs: CheckOffs, hosts: readonly ReviewRequestHost[]): CheckOffs {
-  const requests = new Map(hosts.flatMap((host) => host.requests.map((request) => [request.url, request] as const)));
-  const complete = new Set<string | null>(hosts.filter((host) => host.error === null && !host.truncated).map((host) => host.host));
-  const followed: CheckOffs = {};
+function followListing<C, L extends ListedChangeRequest>(
+  checkOffs: Record<string, C>,
+  hosts: readonly ListedHost[],
+  tab: InboxTab,
+  listOf: (host: ListedHost) => readonly L[],
+  stillOff: (checkOff: C, listed: L) => C | null,
+): Record<string, C> {
+  const listed = new Map(hosts.flatMap((host) => listOf(host).map((item) => [item.url, item] as const)));
+  const complete = new Set<string | null>(hosts.filter((host) => host.error === null && !host.truncated[tab]).map((host) => host.host));
+  const followed: Record<string, C> = {};
   for (const [url, checkOff] of Object.entries(checkOffs)) {
-    const request = requests.get(url);
-    if (request === undefined) {
-      if (!complete.has(hostOf(url))) followed[url] = checkOff;
-    } else if (!cameBack(checkOff, request)) {
-      followed[url] = { headSha: checkOff.headSha, state: request.state };
-    }
+    const item = listed.get(url);
+    const kept = item === undefined ? (complete.has(hostOf(url)) ? null : checkOff) : stillOff(checkOff, item);
+    if (kept !== null) followed[url] = kept;
   }
   return followed;
 }
 
-function cameBack(checkOff: CheckOff, request: ReviewRequest): boolean {
+/**
+ * An assigned check-off comes back on a push, or on a state only the other side brings about.
+ * Otherwise it keeps the state the reviewer is now in, so one they moved on themselves, by commenting, still comes back when they are asked again.
+ */
+function assignedStillOff(checkOff: CheckOff, request: ReviewRequest): CheckOff | null {
   const pushed = request.headSha !== "" && request.headSha !== checkOff.headSha;
-  return pushed || (RETURNING_STATES.includes(request.state) && request.state !== checkOff.state);
+  if (pushed || (RETURNING_STATES.includes(request.state) && request.state !== checkOff.state)) return null;
+  return { headSha: checkOff.headSha, state: request.state };
+}
+
+/**
+ * An authored check-off comes back on any news from its reviewers, never on the author's own push.
+ * Any change to the newest review time counts, since a GitLab approval reset can lower it or clear it.
+ */
+function authoredStillOff(checkOff: AuthoredCheckOff, request: AuthoredChangeRequest): AuthoredCheckOff | null {
+  return request.status === checkOff.status && request.latestReviewAt === checkOff.latestReviewAt ? checkOff : null;
+}
+
+/** One tab's check-offs as the file holds them, leaving out any the plugin no longer reads. */
+function byUrl<T>(stored: unknown, schema: z.ZodType<T>): Record<string, T> {
+  if (typeof stored !== "object" || stored === null) return {};
+  const checkOffs: Record<string, T> = {};
+  for (const [url, value] of Object.entries(stored)) {
+    const parsed = schema.safeParse(value);
+    if (parsed.success) checkOffs[url] = parsed.data;
+  }
+  return checkOffs;
 }
 
 function hostOf(url: string): string | null {
diff --git a/plugins/guided-review/server/inbox-preferences.test.ts b/plugins/guided-review/server/inbox-preferences.test.ts
index fc03be5..364d26f 100644
--- a/plugins/guided-review/server/inbox-preferences.test.ts
+++ b/plugins/guided-review/server/inbox-preferences.test.ts
@@ -12,70 +12,147 @@ async function dataDirectory(t: TestContext): Promise<string> {
   return data;
 }
 
-test("with nothing saved the list hides what the reviewer approved and sorts by the latest update", async (t) => {
+test("with nothing saved each tab hides what is approved and sorts by the latest update", async (t) => {
   const preferences = await new InboxPreferencesFile(await dataDirectory(t)).read();
 
   assert.deepEqual(preferences, {
-    provider: "all",
-    states: ["requested", "commented", "changes-requested", "unapproved"],
-    hideDrafts: false,
-    checkedOff: "hide",
-    needsAttention: false,
-    sort: { key: "updated", descending: true },
-    columns: ["checked", "change", "title", "author", "updated", "state", "local"],
+    assigned: {
+      provider: "all",
+      states: ["requested", "commented", "changes-requested", "unapproved"],
+      hideDrafts: false,
+      checkedOff: "hide",
+      needsAttention: false,
+      sort: { key: "updated", descending: true },
+      columns: ["checked", "change", "title", "author", "updated", "state", "local"],
+    },
+    authored: {
+      provider: "all",
+      states: ["unreviewed", "waiting", "commented", "changes-requested", "approval-reset"],
+      hideDrafts: false,
+      checkedOff: "hide",
+      needsAttention: false,
+      sort: { key: "updated", descending: true },
+      columns: ["checked", "change", "title", "reviewers", "updated", "ci", "state", "local"],
+    },
   });
 });
 
-test("what is saved is read back after a restart", async (t) => {
+test("what is saved for each tab is read back after a restart", async (t) => {
   const data = await dataDirectory(t);
   const saved: InboxPreferences = {
-    provider: "gitlab",
-    states: ["approved", "requested"],
-    hideDrafts: true,
-    checkedOff: "only",
-    needsAttention: true,
-    sort: { key: "size", descending: false },
-    columns: ["title", "ci", "size"],
+    assigned: {
+      provider: "gitlab",
+      states: ["approved", "requested"],
+      hideDrafts: true,
+      checkedOff: "only",
+      needsAttention: true,
+      sort: { key: "size", descending: false },
+      columns: ["title", "ci", "size"],
+    },
+    authored: {
+      provider: "github",
+      states: ["approved", "waiting"],
+      hideDrafts: true,
+      checkedOff: "show",
+      needsAttention: true,
+      sort: { key: "created", descending: false },
+      columns: ["reviewers", "title"],
+    },
   };
 
   await new InboxPreferencesFile(data).save(saved);
 
-  assert.deepEqual(await new InboxPreferencesFile(data).read(), { ...saved, states: ["requested", "approved"], columns: ["title", "size", "ci"] });
+  assert.deepEqual(await new InboxPreferencesFile(data).read(), {
+    assigned: { ...saved.assigned, states: ["requested", "approved"], columns: ["title", "size", "ci"] },
+    authored: { ...saved.authored, states: ["waiting", "approved"], columns: ["title", "reviewers"] },
+  });
 });
 
-test("the title is always among the columns", async (t) => {
+test("saving a change to one tab keeps the other tab's preferences", async (t) => {
+  const data = await dataDirectory(t);
+  const file = new InboxPreferencesFile(data);
+  await file.save({ ...DEFAULT_INBOX_PREFERENCES, authored: { ...DEFAULT_INBOX_PREFERENCES.authored, hideDrafts: true } });
+
+  const read = await file.read();
+  await file.save({ ...read, assigned: { ...read.assigned, provider: "github" } });
+
+  const after = await new InboxPreferencesFile(data).read();
+  assert.equal(after.assigned.provider, "github");
+  assert.deepEqual(after.authored, { ...DEFAULT_INBOX_PREFERENCES.authored, hideDrafts: true });
+});
+
+test("the title is always among a tab's columns", async (t) => {
   const file = new InboxPreferencesFile(await dataDirectory(t));
 
-  assert.deepEqual((await file.save({ ...DEFAULT_INBOX_PREFERENCES, columns: ["author"] })).columns, ["title", "author"]);
+  const saved = await file.save({
+    assigned: { ...DEFAULT_INBOX_PREFERENCES.assigned, columns: ["author"] },
+    authored: { ...DEFAULT_INBOX_PREFERENCES.authored, columns: ["reviewers"] },
+  });
+
+  assert.deepEqual([saved.assigned.columns, saved.authored.columns], [["title", "author"], ["title", "reviewers"]]);
+});
+
+test("a file from before the tabs reads as the Assigned tab's, with the Authored tab at its defaults", async (t) => {
+  const data = await dataDirectory(t);
+  await writeFile(
+    path.join(data, "inbox-preferences.json"),
+    JSON.stringify({ provider: "gitlab", states: ["approved"], hideDrafts: true, checkedOff: "only", needsAttention: true, sort: { key: "size", descending: false }, columns: ["title", "ci"] }),
+  );
+
+  assert.deepEqual(await new InboxPreferencesFile(data).read(), {
+    assigned: {
+      provider: "gitlab",
+      states: ["approved"],
+      hideDrafts: true,
+      checkedOff: "only",
+      needsAttention: true,
+      sort: { key: "size", descending: false },
+      columns: ["title", "ci"],
+    },
+    authored: DEFAULT_INBOX_PREFERENCES.authored,
+  });
 });
 
-test("a field the plugin no longer knows falls back on its own, keeping the rest of the file", async (t) => {
+test("a field the plugin no longer knows falls back on its own, per tab, keeping the rest of the file", async (t) => {
   const data = await dataDirectory(t);
   await writeFile(
     path.join(data, "inbox-preferences.json"),
-    JSON.stringify({ provider: "bitbucket", hideApproved: false, states: ["merged", "approved"], hideDrafts: true, checkedOff: "archived", sort: { key: "stars" }, columns: ["title", "reactions"], extra: 1 }),
+    JSON.stringify({
+      assigned: { provider: "bitbucket", hideApproved: false, states: ["merged", "approved"], hideDrafts: true, checkedOff: "archived", sort: { key: "stars" }, columns: ["title", "reactions"], extra: 1 },
+      authored: { provider: "gitlab", states: ["requested", "waiting"], checkedOff: "only", columns: ["author", "reviewers"] },
+    }),
   );
 
   assert.deepEqual(await new InboxPreferencesFile(data).read(), {
-    ...DEFAULT_INBOX_PREFERENCES,
-    states: ["approved"],
-    hideDrafts: true,
-    columns: ["title"],
+    assigned: { ...DEFAULT_INBOX_PREFERENCES.assigned, states: ["approved"], hideDrafts: true, columns: ["title"] },
+    authored: { ...DEFAULT_INBOX_PREFERENCES.authored, provider: "gitlab", states: ["waiting"], checkedOff: "only", columns: ["title", "reviewers"] },
   });
 });
 
-test("a list of states that would show nothing falls back to the default", async (t) => {
+test("a tab the file has no preferences for reads at its defaults", async (t) => {
   const data = await dataDirectory(t);
-  await writeFile(path.join(data, "inbox-preferences.json"), JSON.stringify({ states: ["merged"] }));
+  await writeFile(path.join(data, "inbox-preferences.json"), JSON.stringify({ assigned: { hideDrafts: true }, authored: "everything" }));
+
+  assert.deepEqual(await new InboxPreferencesFile(data).read(), {
+    assigned: { ...DEFAULT_INBOX_PREFERENCES.assigned, hideDrafts: true },
+    authored: DEFAULT_INBOX_PREFERENCES.authored,
+  });
+});
+
+test("a list of states that would show nothing falls back to the tab's default", async (t) => {
+  const data = await dataDirectory(t);
+  await writeFile(path.join(data, "inbox-preferences.json"), JSON.stringify({ assigned: { states: ["merged"] }, authored: { states: ["requested"] } }));
+
+  const read = await new InboxPreferencesFile(data).read();
 
-  assert.deepEqual((await new InboxPreferencesFile(data).read()).states, DEFAULT_INBOX_PREFERENCES.states);
+  assert.deepEqual([read.assigned.states, read.authored.states], [DEFAULT_INBOX_PREFERENCES.assigned.states, DEFAULT_INBOX_PREFERENCES.authored.states]);
 });
 
 test("saves sent together all land, the last one kept", async (t) => {
   const data = await dataDirectory(t);
   const file = new InboxPreferencesFile(data);
 
-  await Promise.all([true, false, true].map((hideDrafts) => file.save({ ...DEFAULT_INBOX_PREFERENCES, hideDrafts })));
+  await Promise.all([true, false, true].map((hideDrafts) => file.save({ ...DEFAULT_INBOX_PREFERENCES, authored: { ...DEFAULT_INBOX_PREFERENCES.authored, hideDrafts } })));
 
-  assert.equal((await file.read()).hideDrafts, true);
+  assert.equal((await file.read()).authored.hideDrafts, true);
 });
diff --git a/plugins/guided-review/server/inbox-preferences.ts b/plugins/guided-review/server/inbox-preferences.ts
index 832f6d2..059abe9 100644
--- a/plugins/guided-review/server/inbox-preferences.ts
+++ b/plugins/guided-review/server/inbox-preferences.ts
@@ -1,13 +1,14 @@
 import path from "node:path";
 import { InboxPreferencesSchema, type InboxPreferences } from "../shared/inbox-preferences.ts";
+import { byTab } from "./inbox-tabs.ts";
 import { readJson, writeJson } from "./json-file.ts";
 import { oneAtATimePer } from "./one-at-a-time.ts";
 
 const FILE = "inbox-preferences.json";
 
 /**
- * The review list's filters, sort and columns, kept in the data directory because a plugin client
- * has no storage of its own. They are the daemon's, so every client of it shares them.
+ * Each tab's filters, sort and columns, kept in the data directory because a plugin client has no storage of its own.
+ * They are the daemon's, so every client of it shares them.
  */
 export class InboxPreferencesFile {
   readonly #file: string;
@@ -18,7 +19,7 @@ export class InboxPreferencesFile {
   }
 
   async read(): Promise<InboxPreferences> {
-    return InboxPreferencesSchema.parse((await readJson<unknown>(this.#file)) ?? {});
+    return InboxPreferencesSchema.parse(byTab(await readJson<unknown>(this.#file)));
   }
 
   async save(preferences: InboxPreferences): Promise<InboxPreferences> {
diff --git a/plugins/guided-review/server/inbox-tabs.ts b/plugins/guided-review/server/inbox-tabs.ts
new file mode 100644
index 0000000..4150df3
--- /dev/null
+++ b/plugins/guided-review/server/inbox-tabs.ts
@@ -0,0 +1,10 @@
+import { INBOX_TABS } from "../shared/inbox-preferences.ts";
+
+/**
+ * A file kept per tab of the review list, as `{ assigned, authored }`.
+ * One written before the list had tabs holds the Assigned tab's alone, flat, and reads as that.
+ */
+export function byTab(stored: unknown): Record<string, unknown> {
+  if (typeof stored !== "object" || stored === null || Array.isArray(stored)) return {};
+  return INBOX_TABS.some((tab) => tab in stored) ? (stored as Record<string, unknown>) : { assigned: stored };
+}
diff --git a/plugins/guided-review/server/review-inbox.test.ts b/plugins/guided-review/server/review-inbox.test.ts
index 55d0cc0..3bc5de4 100644
--- a/plugins/guided-review/server/review-inbox.test.ts
+++ b/plugins/guided-review/server/review-inbox.test.ts
@@ -1,9 +1,9 @@
 import assert from "node:assert/strict";
-import { mkdtemp, rm } from "node:fs/promises";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import test, { type TestContext } from "node:test";
-import { headMoved, type ReviewRequest, type ReviewRequestHost } from "../shared/inbox.ts";
+import { headMoved, type AuthoredChangeRequest, type AuthoredCheckOff, type ListedHost, type ReviewRequest } from "../shared/inbox.ts";
 import { fakeForge, sampleChangeRequest, type FakeForge } from "./fake-forge.ts";
 import { fakeGuideAgents, sampleGuideReply, type FakeGuideAgents } from "./fake-guide-agents.ts";
 import { fakeWorkspaces, type FakeWorkspaces } from "./fake-workspaces.ts";
@@ -17,7 +17,7 @@ const GITLAB_ID = "gitlab/gitlab.com/acme/uploader/7";
 const HEAD = "b".repeat(40);
 const PUSHED = "d".repeat(40);
 
-type Host = { github: FakeForge; gitlab: FakeForge; workspaces: FakeWorkspaces; guideAgents: FakeGuideAgents; service: ReviewService; restart: () => ReviewService };
+type Host = { data: string; github: FakeForge; gitlab: FakeForge; workspaces: FakeWorkspaces; guideAgents: FakeGuideAgents; service: ReviewService; restart: () => ReviewService };
 
 async function withForges(t: TestContext): Promise<Host> {
   const data = await mkdtemp(path.join(os.tmpdir(), "guided-review-inbox-"));
@@ -32,7 +32,7 @@ async function withForges(t: TestContext): Promise<Host> {
   const guideAgents = fakeGuideAgents();
   guideAgents.answer = () => sampleGuideReply();
   const restart = () => new ReviewService({ forges: [github, gitlab], workspaces, guideAgents, dataDirectory: data });
-  return { github, gitlab, workspaces, guideAgents, service: restart(), restart };
+  return { data, github, gitlab, workspaces, guideAgents, service: restart(), restart };
 }
 
 async function startReview(service: ReviewService, url: string) {
@@ -66,43 +66,90 @@ function request(url: string, overrides: Partial<ReviewRequest> = {}): ReviewReq
   };
 }
 
-function listed(forge: "github" | "gitlab", requests: ReviewRequest[], extra: Partial<ReviewRequestHost> = {}): ReviewRequestHost {
-  return { forge, host: forge === "github" ? "github.com" : "gitlab.com", requests, truncated: false, error: null, ...extra };
+function authored(url: string, overrides: Partial<AuthoredChangeRequest> = {}): AuthoredChangeRequest {
+  const { state: _, viaTeam: __, changedSinceReview: ___, ...listed } = request(url, { author: "reviewer" });
+  return { ...listed, status: "unreviewed", reviewers: [], reviewedSinceLastPush: false, latestReviewAt: null, ...overrides };
 }
 
-test("lists every forge's review requests with their hosts, and none started here has a local review", async (t) => {
+const COMPLETE = { assigned: false, authored: false };
+
+function listed(forge: "github" | "gitlab", assigned: ReviewRequest[], extra: Partial<ListedHost> = {}): ListedHost {
+  return { forge, host: forge === "github" ? "github.com" : "gitlab.com", assigned, authored: [], truncated: COMPLETE, error: null, ...extra };
+}
+
+test("lists every forge's review requests and the viewer's own change requests with their hosts, and none started here has a local review", async (t) => {
   const { github, gitlab, service } = await withForges(t);
-  github.reviewRequests = [listed("github", [request(GITHUB_URL)], { truncated: true })];
-  gitlab.reviewRequests = [
-    listed("gitlab", [request(GITLAB_URL)]),
+  const mine = "https://github.com/acme/uploader/pull/9";
+  github.listedHosts = [listed("github", [request(GITHUB_URL)], { authored: [authored(mine, { number: 9 })], truncated: { assigned: true, authored: false } })];
+  gitlab.listedHosts = [
+    listed("gitlab", [request(GITLAB_URL)], { truncated: { assigned: false, authored: true } }),
     listed("gitlab", [], { host: "gitlab.example.com", error: "glab is not logged in to gitlab.example.com." }),
   ];
 
   const inbox = await service.inbox();
 
   assert.deepEqual(inbox.hosts, [
-    { forge: "github", host: "github.com", truncated: true, error: null },
-    { forge: "gitlab", host: "gitlab.com", truncated: false, error: null },
-    { forge: "gitlab", host: "gitlab.example.com", truncated: false, error: "glab is not logged in to gitlab.example.com." },
+    { forge: "github", host: "github.com", truncated: { assigned: true, authored: false }, error: null },
+    { forge: "gitlab", host: "gitlab.com", truncated: { assigned: false, authored: true }, error: null },
+    { forge: "gitlab", host: "gitlab.example.com", truncated: COMPLETE, error: "glab is not logged in to gitlab.example.com." },
   ]);
-  assert.deepEqual(inbox.items, [
+  assert.deepEqual(inbox.assigned, [
     { ...request(GITHUB_URL), reviewId: GITHUB_ID, local: null, checkedOff: false },
     { ...request(GITLAB_URL), reviewId: GITLAB_ID, local: null, checkedOff: false },
   ]);
+  assert.deepEqual(inbox.authored, [{ ...authored(mine, { number: 9 }), reviewId: "github/github.com/acme/uploader/9", local: null, checkedOff: false }]);
+});
+
+test("a change request of the viewer's reviewed here carries its review, its guide's state, whether the head moved and its drafts", async (t) => {
+  const { github, service } = await withForges(t);
+  await startReview(service, GITHUB_URL);
+
+  github.listedHosts = [listed("github", [], { authored: [authored(GITHUB_URL, { pendingDrafts: 2 })] })];
+  const [item] = (await service.inbox()).authored;
+  assert.equal(item?.reviewId, GITHUB_ID);
+  assert.deepEqual({ ...item?.local, header: null }, { header: null, preparing: null, guide: "ready", workspaceId: "wks_0000000000000001" });
+  assert.equal(headMoved(item!, item!.local!), false);
+  assert.equal(item?.pendingDrafts, 2);
+
+  github.listedHosts = [listed("github", [], { authored: [authored(GITHUB_URL, { headSha: PUSHED })] })];
+  const [pushed] = (await service.inbox()).authored;
+  assert.equal(headMoved(pushed!, pushed!.local!), true);
+});
+
+test("an MR the viewer authored and reviews is listed on both tabs with one review here, its guide and its drafts counted once", async (t) => {
+  const { gitlab, service } = await withForges(t);
+  await startReview(service, GITLAB_URL);
+  gitlab.drafts.set(GITLAB_URL, [{ id: "1", body: "Why the retry cap?", location: { kind: "general" } }]);
+  const listDrafts = gitlab.listDrafts.bind(gitlab);
+  let counted = 0;
+  gitlab.listDrafts = async (ref) => {
+    counted += 1;
+    return listDrafts(ref);
+  };
+
+  gitlab.listedHosts = [listed("gitlab", [request(GITLAB_URL)], { authored: [authored(GITLAB_URL)] })];
+  const inbox = await service.inbox();
+
+  assert.equal(inbox.authored[0]?.reviewId, GITLAB_ID);
+  assert.equal(inbox.assigned[0]?.reviewId, GITLAB_ID);
+  assert.equal(inbox.authored[0]?.local?.guide, "ready");
+  assert.deepEqual(inbox.authored[0]?.local, inbox.assigned[0]?.local);
+  assert.deepEqual([inbox.assigned[0]?.pendingDrafts, inbox.authored[0]?.pendingDrafts], [1, 1]);
+  assert.equal(counted, 1);
 });
 
 test("a change request reviewed here carries its review, its guide's state and whether the forge's head moved past it", async (t) => {
   const { github, service } = await withForges(t);
   await startReview(service, GITHUB_URL);
 
-  github.reviewRequests = [listed("github", [request(GITHUB_URL)])];
-  const [item] = (await service.inbox()).items;
+  github.listedHosts = [listed("github", [request(GITHUB_URL)])];
+  const [item] = (await service.inbox()).assigned;
   assert.equal(item?.local?.header?.headSha, HEAD);
   assert.deepEqual({ ...item?.local, header: null }, { header: null, preparing: null, guide: "ready", workspaceId: "wks_0000000000000001" });
   assert.equal(headMoved(item!, item!.local!), false);
 
-  github.reviewRequests = [listed("github", [request(GITHUB_URL, { headSha: PUSHED })])];
-  const [pushed] = (await service.inbox()).items;
+  github.listedHosts = [listed("github", [request(GITHUB_URL, { headSha: PUSHED })])];
+  const [pushed] = (await service.inbox()).assigned;
   assert.equal(headMoved(pushed!, pushed!.local!), true);
 });
 
@@ -111,8 +158,8 @@ test("a start that failed before the change request was read lists as failed, wi
   github.changeRequests.delete(GITHUB_URL);
   await startReview(service, GITHUB_URL);
 
-  github.reviewRequests = [listed("github", [request(GITHUB_URL)])];
-  const local = (await service.inbox()).items[0]?.local;
+  github.listedHosts = [listed("github", [request(GITHUB_URL)])];
+  const local = (await service.inbox()).assigned[0]?.local;
   assert.equal(local?.preparing?.phase, "failed");
   assert.match(local?.preparing?.message ?? "", /^Could not read /);
   assert.deepEqual({ ...local, preparing: null }, { header: null, preparing: null, guide: "none", workspaceId: null });
@@ -123,8 +170,8 @@ test("a review whose workspace was archived has no workspace to open, and the li
   await startReview(service, GITHUB_URL);
   workspaces.archive("wks_0000000000000001");
 
-  github.reviewRequests = [listed("github", [request(GITHUB_URL)])];
-  const listedLocal = (await service.inbox()).items[0]?.local;
+  github.listedHosts = [listed("github", [request(GITHUB_URL)])];
+  const listedLocal = (await service.inbox()).assigned[0]?.local;
   assert.equal(listedLocal?.workspaceId, null);
   assert.deepEqual(await service.localReviews({ reviewIds: [GITHUB_ID, GITLAB_ID] }), {
     reviews: [
@@ -159,9 +206,9 @@ test("on GitLab the drafts are counted for an MR reviewed here only, and a faile
     { id: "1", body: "Why the retry cap?", location: { kind: "general" } },
     { id: "2", body: "Typo", location: { kind: "file", path: "src/upload.ts" } },
   ]);
-  gitlab.reviewRequests = [listed("gitlab", [request(GITLAB_URL), request(other, { number: 8 })])];
+  gitlab.listedHosts = [listed("gitlab", [request(GITLAB_URL), request(other, { number: 8 })])];
 
-  const items = (await service.inbox()).items;
+  const items = (await service.inbox()).assigned;
   assert.deepEqual(
     items.map((item) => item.pendingDrafts),
     [2, null],
@@ -170,7 +217,7 @@ test("on GitLab the drafts are counted for an MR reviewed here only, and a faile
   gitlab.listDrafts = async () => {
     throw new ForgeError("glab failed: 500 Internal Server Error");
   };
-  assert.equal((await service.inbox()).items[0]?.pendingDrafts, null);
+  assert.equal((await service.inbox()).assigned[0]?.pendingDrafts, null);
 });
 
 test("a GitLab review published from here says whether the head moved since, over the listing's guess", async (t) => {
@@ -178,46 +225,47 @@ test("a GitLab review published from here says whether the head moved since, ove
   await startReview(service, GITLAB_URL);
   const reviewId = "gitlab/gitlab.com/acme/uploader/7";
 
-  gitlab.reviewRequests = [listed("gitlab", [request(GITLAB_URL, { state: "commented", changedSinceReview: null })])];
-  assert.equal((await service.inbox()).items[0]?.changedSinceReview, null, "nothing published from here yet");
+  gitlab.listedHosts = [listed("gitlab", [request(GITLAB_URL, { state: "commented", changedSinceReview: null })])];
+  assert.equal((await service.inbox()).assigned[0]?.changedSinceReview, null, "nothing published from here yet");
 
   const submitted = await service.submit({ reviewId, headSha: HEAD, forgeHeadSha: HEAD, verdict: "comment", body: "Reads well." });
   assert.equal(submitted.status, "submitted");
 
-  gitlab.reviewRequests = [listed("gitlab", [request(GITLAB_URL, { state: "commented", changedSinceReview: true })])];
-  assert.equal((await service.inbox()).items[0]?.changedSinceReview, false, "the head is still the one reviewed");
+  gitlab.listedHosts = [listed("gitlab", [request(GITLAB_URL, { state: "commented", changedSinceReview: true })])];
+  assert.equal((await service.inbox()).assigned[0]?.changedSinceReview, false, "the head is still the one reviewed");
 
-  gitlab.reviewRequests = [listed("gitlab", [request(GITLAB_URL, { state: "commented", headSha: PUSHED, changedSinceReview: false })])];
-  assert.equal((await service.inbox()).items[0]?.changedSinceReview, true, "pushed since");
+  gitlab.listedHosts = [listed("gitlab", [request(GITLAB_URL, { state: "commented", headSha: PUSHED, changedSinceReview: false })])];
+  assert.equal((await service.inbox()).assigned[0]?.changedSinceReview, true, "pushed since");
 
-  gitlab.reviewRequests = [listed("gitlab", [request(GITLAB_URL, { state: "requested", changedSinceReview: null })])];
-  assert.equal((await service.inbox()).items[0]?.changedSinceReview, null, "asked again, which the listing says");
+  gitlab.listedHosts = [listed("gitlab", [request(GITLAB_URL, { state: "requested", changedSinceReview: null })])];
+  assert.equal((await service.inbox()).assigned[0]?.changedSinceReview, null, "asked again, which the listing says");
 });
 
-async function checkedOff(service: ReviewService): Promise<string[]> {
-  return (await service.inbox()).items.filter((item) => item.checkedOff).map((item) => item.url);
+async function checkedOff(service: ReviewService, tab: "assigned" | "authored" = "assigned"): Promise<string[]> {
+  const inbox = await service.inbox();
+  return inbox[tab].filter((item) => item.checkedOff).map((item) => item.url);
 }
 
 test("a check-off holds while the change request stands still, survives a restart and is undone by unchecking", async (t) => {
   const { github, gitlab, service, restart } = await withForges(t);
-  github.reviewRequests = [listed("github", [request(GITHUB_URL)])];
-  gitlab.reviewRequests = [listed("gitlab", [request(GITLAB_URL)])];
+  github.listedHosts = [listed("github", [request(GITHUB_URL)])];
+  gitlab.listedHosts = [listed("gitlab", [request(GITLAB_URL)])];
 
-  await service.setCheckedOff({ url: GITLAB_URL, checkOff: { headSha: HEAD, state: "requested" } });
+  await service.setCheckedOff({ tab: "assigned", url: GITLAB_URL, checkOff: { headSha: HEAD, state: "requested" } });
   assert.deepEqual(await checkedOff(service), [GITLAB_URL]);
   assert.deepEqual(await checkedOff(restart()), [GITLAB_URL], "still requested, as when it was checked off");
 
-  await service.setCheckedOff({ url: GITLAB_URL, checkOff: null });
+  await service.setCheckedOff({ tab: "assigned", url: GITLAB_URL, checkOff: null });
   assert.deepEqual(await checkedOff(service), []);
 });
 
 test("a check-off comes back on a push, or when the reviewer is asked again or loses an approval", async (t) => {
   const { gitlab, service } = await withForges(t);
   const comeBack = async (checkOff: { headSha: string; state: ReviewRequest["state"] }, ...listings: Partial<ReviewRequest>[]) => {
-    await service.setCheckedOff({ url: GITLAB_URL, checkOff });
+    await service.setCheckedOff({ tab: "assigned", url: GITLAB_URL, checkOff });
     const seen: boolean[] = [];
     for (const listing of listings) {
-      gitlab.reviewRequests = [listed("gitlab", [request(GITLAB_URL, listing)])];
+      gitlab.listedHosts = [listed("gitlab", [request(GITLAB_URL, listing)])];
       seen.push((await checkedOff(service)).length === 1);
     }
     return seen;
@@ -236,18 +284,111 @@ test("a check-off comes back on a push, or when the reviewer is asked again or l
 
 test("a check-off goes once a host listed in full no longer has it, and stays while its host fails or has more", async (t) => {
   const { gitlab, service } = await withForges(t);
-  gitlab.reviewRequests = [listed("gitlab", [request(GITLAB_URL)])];
-  await service.setCheckedOff({ url: GITLAB_URL, checkOff: { headSha: HEAD, state: "requested" } });
+  gitlab.listedHosts = [listed("gitlab", [request(GITLAB_URL)])];
+  await service.setCheckedOff({ tab: "assigned", url: GITLAB_URL, checkOff: { headSha: HEAD, state: "requested" } });
 
-  gitlab.reviewRequests = [listed("gitlab", [], { error: "glab is not logged in to gitlab.com." })];
+  gitlab.listedHosts = [listed("gitlab", [], { error: "glab is not logged in to gitlab.com." })];
   await service.inbox();
-  gitlab.reviewRequests = [listed("gitlab", [], { truncated: true })];
+  gitlab.listedHosts = [listed("gitlab", [], { truncated: { assigned: true, authored: false } })];
   await service.inbox();
-  gitlab.reviewRequests = [listed("gitlab", [request(GITLAB_URL)])];
+  gitlab.listedHosts = [listed("gitlab", [request(GITLAB_URL)])];
   assert.deepEqual(await checkedOff(service), [GITLAB_URL]);
 
-  gitlab.reviewRequests = [listed("gitlab", [])];
+  gitlab.listedHosts = [listed("gitlab", [])];
   await service.inbox();
-  gitlab.reviewRequests = [listed("gitlab", [request(GITLAB_URL)])];
+  gitlab.listedHosts = [listed("gitlab", [request(GITLAB_URL)])];
   assert.deepEqual(await checkedOff(service), []);
 });
+
+test("an authored check-off goes once a host listed its authored ones in full without it, and stays while its host fails or has more", async (t) => {
+  const { gitlab, service } = await withForges(t);
+  const mine = (extra: Partial<ListedHost> = {}) => listed("gitlab", [], { authored: [authored(GITLAB_URL)], ...extra });
+  gitlab.listedHosts = [mine()];
+  await service.setCheckedOff({ tab: "authored", url: GITLAB_URL, checkOff: { status: "unreviewed", latestReviewAt: null } });
+
+  gitlab.listedHosts = [listed("gitlab", [], { error: "glab is not logged in to gitlab.com." })];
+  await service.inbox();
+  gitlab.listedHosts = [listed("gitlab", [], { truncated: { assigned: false, authored: true } })];
+  await service.inbox();
+  gitlab.listedHosts = [mine()];
+  assert.deepEqual(await checkedOff(service, "authored"), [GITLAB_URL]);
+
+  gitlab.listedHosts = [listed("gitlab", [], { truncated: { assigned: true, authored: false } })];
+  await service.inbox();
+  gitlab.listedHosts = [mine()];
+  assert.deepEqual(await checkedOff(service, "authored"), [], "only the Authored list having more keeps it");
+});
+
+test("a check-off kept before the list had tabs holds on the Assigned tab", async (t) => {
+  const { data, gitlab, service } = await withForges(t);
+  gitlab.listedHosts = [listed("gitlab", [request(GITLAB_URL)])];
+  const file = path.join(data, "inbox-check-offs.json");
+  await writeFile(file, JSON.stringify({ [GITLAB_URL]: { headSha: HEAD, state: "requested" } }));
+
+  assert.deepEqual(await checkedOff(service), [GITLAB_URL]);
+
+  await service.setCheckedOff({ tab: "assigned", url: GITHUB_URL, checkOff: { headSha: HEAD, state: "requested" } });
+  assert.deepEqual(JSON.parse(await readFile(file, "utf8")), {
+    assigned: { [GITLAB_URL]: { headSha: HEAD, state: "requested" }, [GITHUB_URL]: { headSha: HEAD, state: "requested" } },
+    authored: {},
+  });
+});
+
+test("a check-off on one tab leaves the same MR on the other tab alone, and comes back on that tab only", async (t) => {
+  const { gitlab, service } = await withForges(t);
+  const onBothTabs = (headSha = HEAD, mine: Partial<AuthoredChangeRequest> = {}) => {
+    gitlab.listedHosts = [listed("gitlab", [request(GITLAB_URL, { headSha })], { authored: [authored(GITLAB_URL, { ...mine, headSha })] })];
+  };
+  const tabs = async () => {
+    const inbox = await service.inbox();
+    return [inbox.assigned[0]?.checkedOff, inbox.authored[0]?.checkedOff];
+  };
+  onBothTabs();
+
+  await service.setCheckedOff({ tab: "authored", url: GITLAB_URL, checkOff: { status: "unreviewed", latestReviewAt: null } });
+  assert.deepEqual(await tabs(), [false, true]);
+  await service.setCheckedOff({ tab: "assigned", url: GITLAB_URL, checkOff: { headSha: HEAD, state: "requested" } });
+  assert.deepEqual(await tabs(), [true, true]);
+
+  onBothTabs(PUSHED);
+  assert.deepEqual(await tabs(), [false, true], "a push brings it back on Assigned only");
+
+  await service.setCheckedOff({ tab: "assigned", url: GITLAB_URL, checkOff: { headSha: PUSHED, state: "requested" } });
+  onBothTabs(PUSHED, { status: "commented", latestReviewAt: "2026-09-03T10:00:00Z" });
+  assert.deepEqual(await tabs(), [true, false], "a review brings it back on Authored only");
+});
+
+test("an authored check-off holds while its reviews stand still, survives a restart and is undone by unchecking", async (t) => {
+  const { github, gitlab, service, restart } = await withForges(t);
+  github.listedHosts = [listed("github", [], { authored: [authored(GITHUB_URL, { status: "waiting" })] })];
+  gitlab.listedHosts = [listed("gitlab", [], { authored: [authored(GITLAB_URL, { status: "commented", latestReviewAt: "2026-09-03T10:00:00Z" })] })];
+
+  await service.setCheckedOff({ tab: "authored", url: GITLAB_URL, checkOff: { status: "commented", latestReviewAt: "2026-09-03T10:00:00Z" } });
+  assert.deepEqual(await checkedOff(service, "authored"), [GITLAB_URL]);
+  assert.deepEqual(await checkedOff(restart(), "authored"), [GITLAB_URL], "no review since it was checked off");
+
+  await service.setCheckedOff({ tab: "authored", url: GITLAB_URL, checkOff: null });
+  assert.deepEqual(await checkedOff(service, "authored"), []);
+});
+
+test("an authored check-off comes back when its review status changes or a newer review arrives, and holds over a push", async (t) => {
+  const { gitlab, service } = await withForges(t);
+  const REVIEWED = "2026-09-03T10:00:00Z";
+  const comeBack = async (checkOff: AuthoredCheckOff, ...listings: Partial<AuthoredChangeRequest>[]) => {
+    await service.setCheckedOff({ tab: "authored", url: GITLAB_URL, checkOff });
+    const seen: boolean[] = [];
+    for (const listing of listings) {
+      gitlab.listedHosts = [listed("gitlab", [], { authored: [authored(GITLAB_URL, listing)] })];
+      seen.push((await checkedOff(service, "authored")).length === 1);
+    }
+    return seen;
+  };
+  const approved = { status: "approved", latestReviewAt: REVIEWED } as const;
+
+  assert.deepEqual(await comeBack(approved, { ...approved, headSha: PUSHED }, { ...approved, headSha: HEAD }), [true, true], "a push alone is no news");
+  assert.deepEqual(await comeBack(approved, { status: "changes-requested", latestReviewAt: "2026-09-04T10:00:00Z" }), [false]);
+  assert.deepEqual(await comeBack(approved, { ...approved, latestReviewAt: "2026-09-04T10:00:00Z" }), [false], "approved again by another reviewer");
+  assert.deepEqual(await comeBack({ status: "waiting", latestReviewAt: null }, { status: "commented", latestReviewAt: REVIEWED }), [false]);
+  assert.deepEqual(await comeBack(approved, { status: "approval-reset", latestReviewAt: null, headSha: PUSHED }), [false], "an approval reset, which GitLab leaves with no review");
+  assert.deepEqual(await comeBack(approved, { ...approved, latestReviewAt: "2026-09-02T10:00:00Z" }), [false], "a review taken back, leaving an older one newest");
+});
diff --git a/plugins/guided-review/server/review-inbox.ts b/plugins/guided-review/server/review-inbox.ts
index bb088f3..9966a03 100644
--- a/plugins/guided-review/server/review-inbox.ts
+++ b/plugins/guided-review/server/review-inbox.ts
@@ -1,4 +1,5 @@
-import type { Inbox, InboxItem, LocalReview, ReviewRequest } from "../shared/inbox.ts";
+import type { AuthoredChangeRequest, AuthoredInboxItem, Inbox, InboxItem, ListedChangeRequest, LocalReview, ReviewRequest } from "../shared/inbox.ts";
+import type { InboxTab } from "../shared/inbox-preferences.ts";
 import type { ChangeRequestRef, Forge } from "./forge/port.ts";
 import { awaitsScope, type GuideGenerations } from "./guide-generation.ts";
 import type { InboxCheckOffsFile } from "./inbox-check-offs.ts";
@@ -17,12 +18,10 @@ export type ReviewInboxOptions = {
 };
 
 /**
- * The review requests of every forge, joined with the reviews started here and what the reviewer checked off: the start screen's list.
+ * The review requests of every forge and the viewer's own change requests, joined with the reviews started here and what the viewer checked off on each tab: the start screen's list.
  * Each forge answers per host, so one that cannot be listed leaves the rest listed.
- *
- * GitLab's listing cannot count drafts, which take a call per MR, so they are counted only for the
- * MRs reviewed here; and its guess at a push since the last review is replaced by the head a review
- * from here was published at, which is exact.
+ * GitLab's listing cannot count drafts, which take a call per MR, so they are counted only for the MRs reviewed here.
+ * Its guess at a push since the last review is replaced by the head a review from here was published at, which is exact.
  */
 export class ReviewInbox {
   readonly #forges: readonly Forge[];
@@ -44,11 +43,16 @@ export class ReviewInbox {
   }
 
   async list(): Promise<Inbox> {
-    const listed = (await Promise.all(this.#forges.map((forge) => forge.listReviewRequests()))).flat();
-    const requests = listed.flatMap((host) => host.requests);
+    const listed = (await Promise.all(this.#forges.map((forge) => forge.listChangeRequests()))).flat();
     const checkedOff = await this.#checkOffs.follow(listed);
-    const items = await Promise.all(requests.map(async (request) => ({ ...(await this.#item(request)), checkedOff: checkedOff.has(request.url) })));
-    return { hosts: listed.map(({ requests: _, ...host }) => host), items };
+    const countDrafts = this.#draftCounter();
+    const joinAll = <Request extends ListedChangeRequest, Item>(tab: InboxTab, requests: Request[], join: (request: Request) => Promise<Item>) =>
+      Promise.all(requests.map(async (request) => ({ ...(await join(request)), checkedOff: checkedOff[tab].has(request.url) })));
+    return {
+      hosts: listed.map(({ assigned: _, authored: __, ...host }) => host),
+      assigned: await joinAll("assigned", listed.flatMap((host) => host.assigned), (request) => this.#item(request, countDrafts)),
+      authored: await joinAll("authored", listed.flatMap((host) => host.authored), (request) => this.#authoredItem(request, countDrafts)),
+    };
   }
 
   /** What this plugin has of the review `reviewId` names: null when it was never started here. */
@@ -66,24 +70,49 @@ export class ReviewInbox {
     };
   }
 
-  async #item(request: ReviewRequest): Promise<Omit<InboxItem, "checkedOff">> {
-    const reviewId = idOf(request);
-    const local = reviewId === null ? null : await this.local(reviewId);
-    const record = reviewId === null ? null : await this.#store.get(reviewId);
+  async #item(request: ReviewRequest, countDrafts: DraftCounter): Promise<Omit<InboxItem, "checkedOff">> {
+    const { reviewId, local, record } = await this.#joined(request);
+    if (record === null) return { ...request, reviewId, local };
+    const reviewed = request.forge === "gitlab" && request.state !== "requested" && record.submittedHeadSha !== undefined;
+    return {
+      ...request,
+      pendingDrafts: await this.#pendingDrafts(request, record, countDrafts),
+      changedSinceReview: reviewed ? record.submittedHeadSha !== request.headSha : request.changedSinceReview,
+      reviewId,
+      local,
+    };
+  }
+
+  async #authoredItem(request: AuthoredChangeRequest, countDrafts: DraftCounter): Promise<Omit<AuthoredInboxItem, "checkedOff">> {
+    const { reviewId, local, record } = await this.#joined(request);
     if (record === null) return { ...request, reviewId, local };
-    return { ...request, ...(await this.#fromReview(request, record)), reviewId, local };
+    return { ...request, pendingDrafts: await this.#pendingDrafts(request, record, countDrafts), reviewId, local };
   }
 
-  /** What the review started here knows better than the forge's listing. */
-  async #fromReview(request: ReviewRequest, record: ReviewRecord): Promise<Pick<ReviewRequest, "pendingDrafts" | "changedSinceReview">> {
+  /** The review started here of a listed change request, which is one review whichever tab lists it. */
+  async #joined(listed: ListedChangeRequest): Promise<{ reviewId: string | null; local: LocalReview | null; record: ReviewRecord | null }> {
+    const reviewId = idOf(listed);
+    if (reviewId === null) return { reviewId, local: null, record: null };
+    return { reviewId, local: await this.local(reviewId), record: await this.#store.get(reviewId) };
+  }
+
+  /** The viewer's unpublished comments, counting the ones kept here, which the forge's listing cannot see. */
+  async #pendingDrafts(listed: ListedChangeRequest, record: ReviewRecord, countDrafts: DraftCounter): Promise<number | null> {
+    if (listed.forge === "gitlab") return countDrafts(record);
     const paragraphs = (await this.#store.getDrafts(record.id)).paragraphs.length;
-    if (request.forge === "github") {
-      return { pendingDrafts: request.pendingDrafts === null ? null : request.pendingDrafts + paragraphs, changedSinceReview: request.changedSinceReview };
-    }
-    const reviewed = request.state !== "requested" && record.submittedHeadSha !== undefined;
-    return {
-      pendingDrafts: await this.#countDrafts(record.ref),
-      changedSinceReview: reviewed ? record.submittedHeadSha !== request.headSha : request.changedSinceReview,
+    return listed.pendingDrafts === null ? null : listed.pendingDrafts + paragraphs;
+  }
+
+  /** Counts each review's drafts once however many tabs list it. */
+  #draftCounter(): DraftCounter {
+    const counts = new Map<string, Promise<number | null>>();
+    return (record) => {
+      let count = counts.get(record.id);
+      if (count === undefined) {
+        count = this.#countDrafts(record.ref);
+        counts.set(record.id, count);
+      }
+      return count;
     };
   }
 
@@ -99,7 +128,9 @@ export class ReviewInbox {
 
 }
 
-function idOf({ forge, host, project, number, url }: ReviewRequest): string | null {
+type DraftCounter = (record: ReviewRecord) => Promise<number | null>;
+
+function idOf({ forge, host, project, number, url }: ListedChangeRequest): string | null {
   try {
     return reviewIdOf({ forge, host, project, number, url });
   } catch {
diff --git a/plugins/guided-review/server/review-service.ts b/plugins/guided-review/server/review-service.ts
index eccf0cb..dca0def 100644
--- a/plugins/guided-review/server/review-service.ts
+++ b/plugins/guided-review/server/review-service.ts
@@ -19,7 +19,7 @@ import type {
   SyntaxColors,
 } from "../shared/contracts.ts";
 import type { FileDiff } from "../shared/diff.ts";
-import type { CheckOff, Inbox } from "../shared/inbox.ts";
+import type { CheckOffChange, Inbox } from "../shared/inbox.ts";
 import type { InboxPreferences } from "../shared/inbox-preferences.ts";
 import type { CommentOrigin, DraftList, DraftLocation, LinkedDraft } from "../shared/drafts.ts";
 import type { CoveredCode, GuideState, LayeredGuide } from "../shared/guide.ts";
@@ -153,8 +153,8 @@ export class ReviewService {
     return this.#inboxPreferences.save(preferences);
   }
 
-  async setCheckedOff({ url, checkOff }: { url: string; checkOff: CheckOff | null }): Promise<null> {
-    await this.#checkOffs.set(url, checkOff);
+  async setCheckedOff(change: CheckOffChange): Promise<null> {
+    await this.#checkOffs.set(change);
     return null;
   }
 
diff --git a/plugins/guided-review/shared/contracts.ts b/plugins/guided-review/shared/contracts.ts
index 20e5dd0..ee53dea 100644
--- a/plugins/guided-review/shared/contracts.ts
+++ b/plugins/guided-review/shared/contracts.ts
@@ -5,7 +5,7 @@ import { CommentOriginSchema, DraftListSchema, DraftLocationSchema, LinkedDraftS
 import { ForeignWorkSchema, REVIEW_SCOPES } from "./foreign-work.ts";
 import { GuideStateSchema } from "./guide.ts";
 import { InboxPreferencesSchema } from "./inbox-preferences.ts";
-import { CheckOffSchema, InboxSchema, LocalReviewSchema } from "./inbox.ts";
+import { CheckOffChangeSchema, InboxSchema, LocalReviewSchema } from "./inbox.ts";
 import { GuideProgressSchema } from "./progress.ts";
 import { ReviewHeaderSchema, START_PHASES } from "./review-header.ts";
 import { SubmitResultSchema, VerdictOptionSchema, VerdictSchema } from "./submit.ts";
@@ -119,10 +119,10 @@ export const saveInboxPreferences = defineRpc({
   output: InboxPreferencesSchema,
 });
 
-/** Checks a change request off the review list as of what the row showed, or with null unchecks it. */
+/** Checks a change request off one tab of the review list as of what the row showed, or with null unchecks it. */
 export const setCheckedOff = defineRpc({
   name: "guided-review.inbox.check-off",
-  input: z.object({ url: z.string(), checkOff: CheckOffSchema.nullable() }),
+  input: CheckOffChangeSchema,
   output: z.null(),
 });
 
diff --git a/plugins/guided-review/shared/inbox-preferences.ts b/plugins/guided-review/shared/inbox-preferences.ts
index 985294b..82db8e1 100644
--- a/plugins/guided-review/shared/inbox-preferences.ts
+++ b/plugins/guided-review/shared/inbox-preferences.ts
@@ -1,14 +1,15 @@
 import { z } from "zod";
-import { ReviewerStateSchema, type ReviewerState } from "./inbox.ts";
+import { ReviewerStateSchema, ReviewStatusSchema } from "./inbox.ts";
 
-/** Every column the review list can show, in the order it shows them; the title is what a row is, so it is always shown. */
-export const INBOX_COLUMNS = ["checked", "change", "title", "author", "updated", "created", "size", "ci", "state", "local"] as const;
-export type InboxColumn = (typeof INBOX_COLUMNS)[number];
+/** The review list's tabs: the change requests the reviewer is asked to review, and those they authored. */
+export const INBOX_TABS = ["assigned", "authored"] as const;
+export type InboxTab = (typeof INBOX_TABS)[number];
 
-export const DEFAULT_INBOX_COLUMNS: readonly InboxColumn[] = ["checked", "change", "title", "author", "updated", "state", "local"];
-
-/** With nothing saved the list leaves out what the reviewer approved. */
-export const DEFAULT_INBOX_STATES: readonly ReviewerState[] = ReviewerStateSchema.options.filter((state) => state !== "approved");
+/** Every column a tab can show, in the order it shows them; the title is what a row is, so it is always shown. */
+export const ASSIGNED_COLUMNS = ["checked", "change", "title", "author", "updated", "created", "size", "ci", "state", "local"] as const;
+export const AUTHORED_COLUMNS = ["checked", "change", "title", "reviewers", "updated", "created", "size", "ci", "state", "local"] as const;
+export type AssignedColumn = (typeof ASSIGNED_COLUMNS)[number];
+export type AuthoredColumn = (typeof AUTHORED_COLUMNS)[number];
 
 /** Whether the list leaves out what the reviewer checked off, shows it among the rest, or shows nothing else. */
 export const CHECK_OFF_FILTERS = ["hide", "show", "only"] as const;
@@ -18,27 +19,56 @@ export const INBOX_SORT_KEYS = ["updated", "created", "size"] as const;
 export type InboxSortKey = (typeof INBOX_SORT_KEYS)[number];
 
 /**
- * How the reviewer last left the review list. Each field falls back to its default on its own, so
- * a file written by an older or newer plugin keeps whatever of it still means something.
+ * How the reviewer last left one tab of the review list.
+ * Each field falls back to its default on its own, so a file written by an older or newer plugin keeps whatever of it still means something.
  */
-export const InboxPreferencesSchema = z.object({
-  provider: z.enum(["all", "github", "gitlab"]).catch("all"),
-  /** The reviewer states the list shows, never none, since a list filtered down to nothing is no use. */
-  states: z
-    .array(z.string())
-    .transform((states) => ReviewerStateSchema.options.filter((state) => states.includes(state)))
-    .pipe(z.array(ReviewerStateSchema).min(1))
-    .catch([...DEFAULT_INBOX_STATES]),
-  hideDrafts: z.boolean().catch(false),
-  checkedOff: z.enum(CHECK_OFF_FILTERS).catch("hide"),
-  needsAttention: z.boolean().catch(false),
-  sort: z.object({ key: z.enum(INBOX_SORT_KEYS), descending: z.boolean() }).catch({ key: "updated", descending: true }),
-  columns: z
-    .array(z.string())
-    .transform((columns) => INBOX_COLUMNS.filter((column) => column === "title" || columns.includes(column)))
-    .catch([...DEFAULT_INBOX_COLUMNS]),
+function tabPreferencesSchema<State extends string, Column extends string>(tab: {
+  states: readonly State[];
+  defaultStates: readonly State[];
+  columns: readonly Column[];
+  defaultColumns: readonly Column[];
+}) {
+  const schema = z.object({
+    provider: z.enum(["all", "github", "gitlab"]).catch("all"),
+    /** The states the tab shows, never none, since a list filtered down to nothing is no use. */
+    states: z
+      .array(z.string())
+      .transform((states) => tab.states.filter((state) => states.includes(state)))
+      .refine((states) => states.length > 0)
+      .catch([...tab.defaultStates]),
+    hideDrafts: z.boolean().catch(false),
+    checkedOff: z.enum(CHECK_OFF_FILTERS).catch("hide"),
+    needsAttention: z.boolean().catch(false),
+    sort: z.object({ key: z.enum(INBOX_SORT_KEYS), descending: z.boolean() }).catch({ key: "updated", descending: true }),
+    columns: z
+      .array(z.string())
+      .transform((columns) => tab.columns.filter((column) => column === "title" || columns.includes(column)))
+      .catch([...tab.defaultColumns]),
+  });
+  return schema.catch(() => schema.parse({}));
+}
+
+/** With nothing saved the Assigned tab leaves out what the reviewer approved. */
+export const AssignedPreferencesSchema = tabPreferencesSchema({
+  states: ReviewerStateSchema.options,
+  defaultStates: ReviewerStateSchema.options.filter((state) => state !== "approved"),
+  columns: ASSIGNED_COLUMNS,
+  defaultColumns: ["checked", "change", "title", "author", "updated", "state", "local"],
 });
 
+/** With nothing saved the Authored tab leaves out what someone approved, and shows CI, which is the author's to fix. */
+export const AuthoredPreferencesSchema = tabPreferencesSchema({
+  states: ReviewStatusSchema.options,
+  defaultStates: ReviewStatusSchema.options.filter((status) => status !== "approved"),
+  columns: AUTHORED_COLUMNS,
+  defaultColumns: ["checked", "change", "title", "reviewers", "updated", "ci", "state", "local"],
+});
+
+/** Both tabs' preferences, which travel together since the client saves them whole. */
+export const InboxPreferencesSchema = z.object({ assigned: AssignedPreferencesSchema, authored: AuthoredPreferencesSchema });
+
+export type AssignedPreferences = z.output<typeof AssignedPreferencesSchema>;
+export type AuthoredPreferences = z.output<typeof AuthoredPreferencesSchema>;
 export type InboxPreferences = z.output<typeof InboxPreferencesSchema>;
 
 export const DEFAULT_INBOX_PREFERENCES: InboxPreferences = InboxPreferencesSchema.parse({});
diff --git a/plugins/guided-review/shared/inbox.ts b/plugins/guided-review/shared/inbox.ts
index ad31a08..832f537 100644
--- a/plugins/guided-review/shared/inbox.ts
+++ b/plugins/guided-review/shared/inbox.ts
@@ -7,11 +7,17 @@ import { ReviewHeaderSchema, START_PHASES } from "./review-header.ts";
  */
 export const ReviewerStateSchema = z.enum(["requested", "commented", "changes-requested", "approved", "unapproved"]);
 
+/**
+ * Where the author's change request stands with its reviewers, combined from each one's latest review, in the same words on both forges.
+ * `approval-reset` is an approval taken back by a push; on GitLab, a reviewer revoking their approval reads the same.
+ */
+export const ReviewStatusSchema = z.enum(["unreviewed", "waiting", "commented", "changes-requested", "approved", "approval-reset"]);
+
 /** The head's CI as one word; null when it has none, or one in a state neither of these is, like a cancelled pipeline. */
 export const CiStateSchema = z.enum(["success", "failure", "pending"]);
 
-/** An open change request the reviewer is one of the reviewers of, as a forge lists it. */
-export const ReviewRequestSchema = z.object({
+/** An open change request as a forge lists it, whichever tab of the review list it is on. */
+export const ListedChangeRequestSchema = z.object({
   forge: z.enum(["github", "gitlab"]),
   /** The web host, lower-cased: `github.com`. */
   host: z.string(),
@@ -29,6 +35,12 @@ export const ReviewRequestSchema = z.object({
   deletions: z.number().int(),
   fileCount: z.number().int(),
   ci: CiStateSchema.nullable(),
+  /** The viewer's unpublished comments on it; null where the forge cannot count them cheaply. */
+  pendingDrafts: z.number().int().nullable(),
+});
+
+/** An open change request the reviewer is one of the reviewers of, as a forge lists it. */
+export const ReviewRequestSchema = ListedChangeRequestSchema.extend({
   state: ReviewerStateSchema,
   /** The team the review was asked of, `org/team`, when it was not asked of the reviewer by name. */
   viaTeam: z.string().nullable(),
@@ -37,26 +49,51 @@ export const ReviewRequestSchema = z.object({
    * again. Null when they never reviewed it, or the forge cannot say.
    */
   changedSinceReview: z.boolean().nullable(),
-  /** The reviewer's unpublished comments on it; null where the forge cannot count them cheaply. */
-  pendingDrafts: z.number().int().nullable(),
+});
+
+/** A person or team asked to review the author's change request, or who reviewed it, by where their latest review stands. */
+export const ReviewerSchema = z.object({
+  /** A login, or `org/team` for a team. */
+  name: z.string(),
+  state: ReviewerStateSchema,
+});
+
+/** An open change request the viewer authored, as a forge lists it; `author` is always the viewer. */
+export const AuthoredChangeRequestSchema = ListedChangeRequestSchema.extend({
+  status: ReviewStatusSchema,
+  reviewers: z.array(ReviewerSchema),
+  /** Whether a review arrived after the head commit was pushed; null where the forge cannot say. */
+  reviewedSinceLastPush: z.boolean().nullable(),
+  /** When the newest review arrived; null before any did. */
+  latestReviewAt: z.string().nullable(),
 });
 
 export type ReviewerState = z.output<typeof ReviewerStateSchema>;
+export type ReviewStatus = z.output<typeof ReviewStatusSchema>;
 export type CiState = z.output<typeof CiStateSchema>;
 export type ReviewRequest = z.output<typeof ReviewRequestSchema>;
+export type Reviewer = z.output<typeof ReviewerSchema>;
+export type ListedChangeRequest = z.output<typeof ListedChangeRequestSchema>;
+export type AuthoredChangeRequest = z.output<typeof AuthoredChangeRequestSchema>;
 
-/** What one host of a forge listed, or why it could not, so one host failing leaves the others listed. */
-export const ReviewRequestHostSchema = z.object({
+/**
+ * What one host of a forge listed, or why it could not, so one host failing leaves the others listed.
+ * Both lists come from one listing, so a host fails for both at once and says so once.
+ */
+export const ListedHostSchema = z.object({
   forge: z.enum(["github", "gitlab"]),
   host: z.string(),
-  requests: z.array(ReviewRequestSchema),
-  /** The host has more than were listed. */
-  truncated: z.boolean(),
-  /** Why the host could not be listed, as a sentence; its `requests` are then empty. */
+  /** What the viewer is asked to review. */
+  assigned: z.array(ReviewRequestSchema),
+  /** What the viewer authored. */
+  authored: z.array(AuthoredChangeRequestSchema),
+  /** Which of the host's lists has more than was listed. */
+  truncated: z.object({ assigned: z.boolean(), authored: z.boolean() }),
+  /** Why the host could not be listed, as a sentence; both its lists are then empty. */
   error: z.string().nullable(),
 });
 
-export type ReviewRequestHost = z.output<typeof ReviewRequestHostSchema>;
+export type ListedHost = z.output<typeof ListedHostSchema>;
 
 /**
  * What this plugin has of a change request's review, if the reviewer started one here: the start
@@ -72,29 +109,46 @@ export const LocalReviewSchema = z.object({
   workspaceId: z.string().nullable(),
 });
 
-export const InboxItemSchema = ReviewRequestSchema.extend({
-  /** The ID a review of it is kept under; null when it cannot be kept. */
+/** What the review list joins to a listed change request, on either tab. */
+const JOINED = {
+  /** The ID a review of it is kept under, the same on both tabs; null when it cannot be kept. */
   reviewId: z.string().nullable(),
   local: LocalReviewSchema.nullable(),
-  /** The reviewer set it aside on this list, the forge none the wiser, until it moves on (`server/inbox-check-offs.ts`). */
+  /** The viewer set it aside on this tab, the forge none the wiser, until it moves on (`server/inbox-check-offs.ts`). */
   checkedOff: z.boolean(),
-});
+};
+
+export const InboxItemSchema = ReviewRequestSchema.extend(JOINED);
+export const AuthoredInboxItemSchema = AuthoredChangeRequestSchema.extend(JOINED);
 
 /** What the reviewer saw of a change request when they checked it off. */
 export const CheckOffSchema = z.object({ headSha: z.string(), state: ReviewerStateSchema });
 
-/** Every host's review requests, each joined with the review started here, if any. */
+/** What the author saw of their change request when they checked it off: where it stood with its reviewers, and when the newest review arrived. */
+export const AuthoredCheckOffSchema = z.object({ status: ReviewStatusSchema, latestReviewAt: z.string().nullable() });
+
+/** A check-off set on one tab as of what its row showed, or with null taken back. */
+export const CheckOffChangeSchema = z.discriminatedUnion("tab", [
+  z.object({ tab: z.literal("assigned"), url: z.string(), checkOff: CheckOffSchema.nullable() }),
+  z.object({ tab: z.literal("authored"), url: z.string(), checkOff: AuthoredCheckOffSchema.nullable() }),
+]);
+
+/** Every host's review requests and the viewer's own change requests, each joined with the review started here, if any. */
 export const InboxSchema = z.object({
-  hosts: z.array(ReviewRequestHostSchema.omit({ requests: true })),
-  items: z.array(InboxItemSchema),
+  hosts: z.array(ListedHostSchema.omit({ assigned: true, authored: true })),
+  assigned: z.array(InboxItemSchema),
+  authored: z.array(AuthoredInboxItemSchema),
 });
 
 export type LocalReview = z.output<typeof LocalReviewSchema>;
 export type CheckOff = z.output<typeof CheckOffSchema>;
+export type AuthoredCheckOff = z.output<typeof AuthoredCheckOffSchema>;
+export type CheckOffChange = z.output<typeof CheckOffChangeSchema>;
 export type InboxItem = z.output<typeof InboxItemSchema>;
+export type AuthoredInboxItem = z.output<typeof AuthoredInboxItemSchema>;
 export type Inbox = z.output<typeof InboxSchema>;
 
 /** Whether the forge's head moved past the one the review here was read at. */
-export function headMoved(item: ReviewRequest, local: LocalReview): boolean {
+export function headMoved(item: Pick<ListedChangeRequest, "headSha">, local: LocalReview): boolean {
   return local.header !== null && item.headSha !== "" && item.headSha !== local.header.headSha;
 }