diff --git a/README.md b/README.md
index b3235aa..3ff0271 100644
--- a/README.md
+++ b/README.md
@@ -332,7 +332,9 @@ running past the end would otherwise be counted and highlighted with nothing to
 
 ## The review inbox
 
-`diffity inbox` watches the pull requests awaiting your review and prepares each one ahead of time, so the review is ready the moment you look. It polls GitHub (`gh search prs --review-requested=@me`), and for each pull request worth your attention it cuts a worktree at the PR head, runs a diffity session over the diff, has an agent prepare a review with a walkthrough, and saves the result as a bundle. New commits redo a stale review; a merged, closed, or no-longer-requested PR is retired. The daemon prepares up to `maxPrepared` of them from the queue on its own — the rest wait, smallest first — and a prepared review leaves the inbox once you have posted it (GitHub withdraws the request) or dismissed it from the page — a dismissal holds until the pull request gets new commits, and dismissed pull requests stay listed at the bottom so one can be brought back. A queued, skipped, failed or dismissed pull request has a ↑ button: prepare this one now — at once and in parallel with whatever the daemon is preparing, past the auto-prepare count, with the filter, the title patterns and the CI hold set aside. Each bump is its own agent run, and the row says `preparing` while it runs. Each prepared review shows its findings by severity ("1 P1 · 2 P2"), and the page can notify you when one is ready — click "Turn on notifications" once to allow it, and ⟳ in the header polls GitHub now instead of at the next interval; `localhost` counts as a secure context, so this works from the pinned tab with nothing else set up.
+`diffity inbox` watches the pull requests awaiting your review and prepares each one ahead of time, so the review is ready the moment you look. It polls GitHub (`gh search prs --review-requested=@me`), and for each pull request worth your attention it cuts a worktree at the PR head, runs a diffity session over the diff, has an agent prepare a review with a walkthrough, and saves the result as a bundle. New commits redo a stale review; a merged, closed, or no-longer-requested PR is retired. The daemon prepares up to `maxPrepared` of them from the queue on its own — the rest wait, smallest first — and a prepared review leaves the Ready list once you have posted it (GitHub withdraws the request, and the pull request moves to Handled, below) or dismissed it from the page — a dismissal holds until the pull request gets new commits, and dismissed pull requests stay listed at the bottom so one can be brought back. A queued, skipped, failed or dismissed pull request has a ↑ button: prepare this one now — at once and in parallel with whatever the daemon is preparing, past the auto-prepare count, with the filter, the title patterns and the CI hold set aside. Each bump is its own agent run, and the row says `preparing` while it runs. Each prepared review shows its findings by severity ("1 P1 · 2 P2"), and the page can notify you when one is ready — click "Turn on notifications" once to allow it, and ⟳ in the header polls GitHub now instead of at the next interval; `localhost` counts as a secure context, so this works from the pinned tab with nothing else set up.
+
+Every review you post from diffity is noted against its pull request, with the commit it was posted against, and the pull request then stays under **Handled** instead of vanishing when GitHub withdraws the review request. The card links to the pull request itself — the worktree is reclaimed once the review is out — and says what you said: "you approved", "you requested changes", "you commented", and when. When the author pushes after your review, the card moves to the top of the list, reads "new commits since you approved" and is badged `updated`, so a pull request that has come back to you is not something you have to remember; ↑ prepares a fresh review of the current head, re-request or not, and × sets the row aside until the next push. A pull request leaves the list when the author asks for a new review — the search lists it again and it goes back in the queue like anything else — or when it is merged or closed. This counts reviews posted from any diffity, so one you posted from your own clone brings its pull request into the list at the next poll, at the cost of one `gh pr view`. `diffity inbox status` prints the same list.
 
 The daemon never posts your prepared reviews to GitHub — they are local drafts you open and submit yourself — and it runs the review agent with your GitHub credentials stripped from its environment. Its own git calls run with hooks disabled, so a checkout's hook scripts — the author's code — never run with your credentials. That said, the agent executes the pull request's own repository code (see the warning below), so treat the "never posts" behaviour as the daemon's design, not a sandbox.
 
diff --git a/package-lock.json b/package-lock.json
index ba13e7b..cf63643 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -8457,7 +8457,7 @@
     },
     "packages/api": {
       "name": "@diffity/api",
-      "version": "0.10.28",
+      "version": "0.10.29",
       "dependencies": {
         "@diffity/parser": "*"
       },
@@ -8468,7 +8468,7 @@
     },
     "packages/cli": {
       "name": "@naturalcycles/diffity",
-      "version": "0.10.28",
+      "version": "0.10.29",
       "license": "MIT",
       "dependencies": {
         "commander": "^14.0.3",
@@ -8492,7 +8492,7 @@
     },
     "packages/git": {
       "name": "@diffity/git",
-      "version": "0.10.28",
+      "version": "0.10.29",
       "devDependencies": {
         "@types/node": "^25.5.0",
         "typescript": "^5.9.3",
@@ -8501,7 +8501,7 @@
     },
     "packages/github": {
       "name": "@diffity/github",
-      "version": "0.10.28",
+      "version": "0.10.29",
       "dependencies": {
         "@diffity/api": "*",
         "@diffity/parser": "*"
@@ -8514,7 +8514,7 @@
     },
     "packages/parser": {
       "name": "@diffity/parser",
-      "version": "0.10.28",
+      "version": "0.10.29",
       "devDependencies": {
         "typescript": "^5.9.3",
         "vitest": "^4.1.0"
@@ -8522,7 +8522,7 @@
     },
     "packages/ui": {
       "name": "@diffity/ui",
-      "version": "0.10.28",
+      "version": "0.10.29",
       "dependencies": {
         "@diffity/api": "*",
         "@diffity/parser": "*",
diff --git a/packages/api/package.json b/packages/api/package.json
index 0f7a86a..639dfbd 100644
--- a/packages/api/package.json
+++ b/packages/api/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@diffity/api",
-  "version": "0.10.28",
+  "version": "0.10.29",
   "private": true,
   "type": "module",
   "main": "./dist/index.js",
diff --git a/packages/cli/package.json b/packages/cli/package.json
index 3155bd6..8fa4dc4 100644
--- a/packages/cli/package.json
+++ b/packages/cli/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@naturalcycles/diffity",
-  "version": "0.10.28",
+  "version": "0.10.29",
   "description": "Agent-agnostic, GitHub-style diff viewer and code review tool with a live agent loop",
   "type": "module",
   "bin": {
diff --git a/packages/cli/src/commands/inbox.ts b/packages/cli/src/commands/inbox.ts
index 1d97653..f099e4e 100644
--- a/packages/cli/src/commands/inbox.ts
+++ b/packages/cli/src/commands/inbox.ts
@@ -87,7 +87,8 @@ export function registerInboxCommand(program: Command): void {
         return;
       }
 
-      if (view.ready.length === 0 && view.working.length === 0 && view.other.length === 0 && view.dismissed.length === 0) {
+      if (view.ready.length === 0 && view.working.length === 0 && view.handled.length === 0
+        && view.other.length === 0 && view.dismissed.length === 0) {
         console.log(pc.dim('Nothing in the inbox yet. Run `diffity inbox` to start watching.'));
         spent(view);
         return;
@@ -99,6 +100,9 @@ export function registerInboxCommand(program: Command): void {
       section('Queue', view.working.map(row =>
         `  ${pc.dim(row.status.padEnd(9))} ${row.repo}#${row.number} ${row.title} ${pc.dim(row.statusReason ?? '')}`,
       ));
+      section('Handled', view.handled.map(row =>
+        `  ${pc.dim((row.handled?.updated ? 'updated' : 'handled').padEnd(9))} ${row.repo}#${row.number} ${row.title} ${pc.dim(row.statusReason ?? '')}`,
+      ));
       section('Other', view.other.map(row =>
         `  ${pc.dim(row.status.padEnd(9))} ${row.repo}#${row.number} ${pc.dim(row.statusReason ?? '')}`,
       ));
diff --git a/packages/cli/src/inbox/handled.ts b/packages/cli/src/inbox/handled.ts
new file mode 100644
index 0000000..bca20be
--- /dev/null
+++ b/packages/cli/src/inbox/handled.ts
@@ -0,0 +1,37 @@
+import type { ReviewEvent } from '@diffity/api';
+import { inboxStorePath } from './paths.js';
+import { InboxStore, prId } from './store.js';
+
+/**
+ * Notes that a review reached the forge, so the inbox keeps listing the pull request instead of
+ * losing it the moment GitHub withdraws the review request.
+ *
+ * The store is opened and closed around the one write: this runs in whichever diffity posted the
+ * review — a session the inbox prepared, or one the reviewer started on their own clone — and none
+ * of those hold the inbox open otherwise.
+ */
+export function recordHandledReview(input: {
+  owner: string;
+  repo: string;
+  number: number;
+  /** The head the review was posted against. */
+  headSha: string;
+  event: ReviewEvent;
+  reviewUrl: string | null;
+  now: string;
+  /** The reviewer's own inbox unless a test says otherwise. */
+  storePath?: string;
+}): void {
+  const store = new InboxStore(input.storePath ?? inboxStorePath());
+  try {
+    store.recordHandled({
+      prId: prId(input),
+      headSha: input.headSha,
+      event: input.event,
+      reviewUrl: input.reviewUrl,
+      at: input.now,
+    });
+  } finally {
+    store.close();
+  }
+}
diff --git a/packages/cli/src/inbox/open.ts b/packages/cli/src/inbox/open.ts
index f76bc0a..db54455 100644
--- a/packages/cli/src/inbox/open.ts
+++ b/packages/cli/src/inbox/open.ts
@@ -1,6 +1,6 @@
 import type { InboxPr, InboxStore } from './store.js';
 
-export const BUMPABLE: ReadonlySet<InboxPr['status']> = new Set(['queued', 'skipped', 'failed', 'dismissed']);
+export const BUMPABLE: ReadonlySet<InboxPr['status']> = new Set(['queued', 'skipped', 'failed', 'dismissed', 'handled']);
 
 export type Resolution =
   | { ok: true; pr: InboxPr }
@@ -42,8 +42,8 @@ export function resolveDismiss(store: InboxStore, id: string): Resolution {
 
 /**
  * Whether a pull request can be bumped to the front of the queue: one that is waiting, one a verdict
- * or a failure set aside, or one the reviewer dismissed and wants back. A prepared, stale or
- * in-flight one has nothing to gain.
+ * or a failure set aside, one the reviewer dismissed and wants back, or one already reviewed whose
+ * current head they want a fresh review of. A prepared, stale or in-flight one has nothing to gain.
  */
 export function resolveBump(store: InboxStore, id: string): Resolution {
   const pr = store.get(id);
@@ -51,7 +51,7 @@ export function resolveBump(store: InboxStore, id: string): Resolution {
     return { ok: false, status: 404, message: `No pull request ${id} in the inbox.` };
   }
   if (!BUMPABLE.has(pr.status)) {
-    return { ok: false, status: 409, message: `${id} is ${pr.status}; only a queued, skipped, failed or dismissed pull request can be bumped.` };
+    return { ok: false, status: 409, message: `${id} is ${pr.status}; only a queued, skipped, failed, dismissed or handled pull request can be bumped.` };
   }
   return { ok: true, pr };
 }
diff --git a/packages/cli/src/inbox/page.ts b/packages/cli/src/inbox/page.ts
index 3778721..c7d880c 100644
--- a/packages/cli/src/inbox/page.ts
+++ b/packages/cli/src/inbox/page.ts
@@ -1,6 +1,6 @@
 /**
  * The inbox page, served at `/`. Self-contained (no build step, no external requests): it polls
- * `/api/inbox` and renders the three groups, opening a prepared review in a new tab via `/open/:id`.
+ * `/api/inbox` and renders its groups, opening a prepared review in a new tab via `/open/:id`.
  */
 export function inboxPage(): string {
   return `<!doctype html>
@@ -121,6 +121,10 @@ export function inboxPage(): string {
     <h2>Queue</h2>
     <div id="working"></div>
   </section>
+  <section id="handled-section" hidden>
+    <h2>Handled</h2>
+    <div id="handled"></div>
+  </section>
   <section id="other-section" hidden>
     <h2>Other</h2>
     <div id="other"></div>
@@ -251,6 +255,34 @@ export function inboxPage(): string {
     return row;
   }
 
+  const VERDICTS = { APPROVE: 'you approved', REQUEST_CHANGES: 'you requested changes', COMMENT: 'you commented' };
+
+  /** What the reviewer said about a pull request, and whether the author has pushed since. */
+  function verdict(h) {
+    const said = VERDICTS[h.event] || 'you reviewed';
+    return h.updated ? 'new commits since ' + said : said;
+  }
+
+  // A handled row has no worktree left to open — it was reclaimed when the review was posted — so
+  // it links to the pull request itself.
+  function handledRow(r) {
+    const h = r.handled;
+    const row = document.createElement('a');
+    row.className = 'row open';
+    row.href = r.url;
+    row.target = '_blank';
+    row.rel = 'noopener';
+    row.innerHTML =
+      '<span class="size">' + sizeLabel(r) + '</span>' +
+      ciDot(r) +
+      '<span class="title"><div><span class="repo">' + esc(r.repo) + '#' + r.number + '</span> ' +
+      '<span class="name">' + esc(r.title) + '</span></div>' +
+      metaLine(['by ' + esc(r.author), verdict(h), ago(h.at), esc(h.headSha.slice(0, 7))],
+        'reviewed at ' + h.headSha + (h.reviewUrl ? '\\n' + h.reviewUrl : '')) + '</span>' +
+      '<span class="badge ' + (h.updated ? 'alert' : 'work') + '">' + (h.updated ? 'updated' : 'handled') + '</span>';
+    return row;
+  }
+
   function plainRow(r, badgeClass, badgeText, busy) {
     const row = document.createElement('div');
     row.className = busy ? 'row busy' : 'row';
@@ -274,7 +306,10 @@ export function inboxPage(): string {
     return plainRow(r, busy ? 'work busy' : 'work', label, busy);
   }
 
-  function withActions(row, r) {
+  const BUMP_TITLE = 'Prepare this one now: at once and beside whatever is being prepared, past the auto-prepare count, the skips and the CI hold set aside';
+  const REPREPARE_TITLE = 'Prepare a fresh review of the current head';
+
+  function withActions(row, r, bumpTitle) {
     if (!r.dismissUrl && !r.prepareUrl) return row;
     const wrap = document.createElement('div');
     wrap.className = 'entry';
@@ -283,7 +318,7 @@ export function inboxPage(): string {
       const up = document.createElement('button');
       up.type = 'button';
       up.className = 'bump';
-      up.title = 'Prepare this one now: at once and beside whatever is being prepared, past the auto-prepare count, the skips and the CI hold set aside';
+      up.title = bumpTitle || BUMP_TITLE;
       up.textContent = '\\u2191';
       up.onclick = () => bump(r);
       wrap.append(up);
@@ -450,12 +485,13 @@ export function inboxPage(): string {
       announce(view);
       fill('ready-section', 'ready', view.ready, r => withActions(readyRow(r), r));
       fill('working-section', 'working', view.working, r => withActions(workingRow(r), r));
+      fill('handled-section', 'handled', view.handled, r => withActions(handledRow(r), r, REPREPARE_TITLE));
       fill('other-section', 'other', view.other, r => {
         const bad = r.status === 'failed';
         return withActions(plainRow(r, bad ? 'bad' : 'work', r.status), r);
       });
       fill('dismissed-section', 'dismissed', view.dismissed, r => withActions(plainRow(r, 'work', 'dismissed'), r));
-      const total = view.ready.length + view.working.length + view.other.length + view.dismissed.length;
+      const total = view.ready.length + view.working.length + view.handled.length + view.other.length + view.dismissed.length;
       el('all-empty').hidden = total > 0;
       el('status').textContent = view.ready.length + ' ready \\u00b7 ' + view.working.length + ' queued';
       showReload(view.ticking === true);
diff --git a/packages/cli/src/inbox/reconcile.ts b/packages/cli/src/inbox/reconcile.ts
index c0351f1..ee171fa 100644
--- a/packages/cli/src/inbox/reconcile.ts
+++ b/packages/cli/src/inbox/reconcile.ts
@@ -1,5 +1,5 @@
 import { ciState, type PrCheck, type PrSnapshot } from '@diffity/github';
-import type { InboxPr, InboxStatus } from './store.js';
+import type { Handled, InboxPr, InboxStatus } from './store.js';
 
 /** How many times preparation is retried at one head before the pull request is left as failed. */
 export const MAX_PREPARE_ATTEMPTS = 3;
@@ -20,6 +20,11 @@ export interface ReconcileInput {
   /** Whether this poll's search listed the PR as awaiting the reviewer. */
   requested: boolean;
   viewerLogin: string | null;
+  /**
+   * The last review diffity posted for this pull request; absent or null is none, as an unreviewed
+   * one has.
+   */
+  handled?: Handled | null;
   /**
    * Whether a pull request waits for its CI before an agent is spent on it; absent is off, as the
    * config's default is.
@@ -42,8 +47,9 @@ const TITLE_MATCHES = 'title matches';
  * The status a pull request should move to, given what the forge now says and what the inbox
  * already did — the whole decision in one pure function, so every branch is a plain test.
  *
- * Nothing prepares a draft, the reviewer's own pull request, or a bot's. A closed or merged one, or
- * one no longer asking for the review, is retired but keeps whatever was prepared. A new commit
+ * Nothing prepares a draft, the reviewer's own pull request, or a bot's. A closed or merged one is
+ * retired but keeps whatever was prepared; one no longer asking for the review is retired too,
+ * unless a review was posted for it from diffity — that one stays listed as handled. A new commit
  * makes a prepared review stale and worth redoing. One the reviewer dismissed stays dismissed until
  * it gets new commits; one they bumped is prepared whatever else would have held it back, drafts
  * apart. A title matching one of the reviewer's patterns is skipped before any agent is spent on
@@ -143,8 +149,31 @@ function decide(input: ReconcileInput): Transition | null {
   if (!requested) {
     if (snapshot.state === 'MERGED') return settled('done', 'merged');
     if (snapshot.state === 'CLOSED') return settled('done', 'closed');
-    // Open, but no longer in the review-requested search: the request was withdrawn or already met.
-    return settled('hidden', 'review no longer requested');
+    const handled = input.handled ?? null;
+    if (!handled) {
+      // Open, but never reviewed from diffity and no longer in the review-requested search: the
+      // request was withdrawn, or met somewhere else.
+      return settled('hidden', 'review no longer requested');
+    }
+    // A dismissal covers this version of the pull request here as it does everywhere else.
+    if (existing?.status === 'dismissed' && existing.headSha === snapshot.headSha) {
+      return null;
+    }
+    // A bump on a handled pull request owns the row while its preparation runs, and the review it
+    // produced stays openable until that one is posted too.
+    if (existing?.status === 'queued' || existing?.status === 'preparing') {
+      return null;
+    }
+    // A preparation that failed says so until the head moves, as it does on a requested row: the
+    // reviewer asked for that review and wants to know it did not happen.
+    if (existing?.status === 'failed' && existing.headSha === snapshot.headSha) {
+      return null;
+    }
+    if ((existing?.status === 'prepared' || existing?.status === 'stale')
+      && (existing.preparedAt ?? '') > handled.at) {
+      return null;
+    }
+    return settled('handled', handledReason(handled, snapshot));
   }
 
   // A dismissal is the reviewer's word on this version of the pull request; a new head is a new
@@ -198,6 +227,18 @@ function decide(input: ReconcileInput): Transition | null {
   return { status: 'queued', reason: null, prepare: true };
 }
 
+/** What the reviewer said, and whether the author has pushed since they said it. */
+function handledReason(handled: Handled, snapshot: PrSnapshot): string {
+  const verdict = HANDLED_VERDICTS[handled.event];
+  return handled.headSha === snapshot.headSha ? verdict : `new commits since ${verdict}`;
+}
+
+const HANDLED_VERDICTS: Record<Handled['event'], string> = {
+  APPROVE: 'you approved',
+  REQUEST_CHANGES: 'you requested changes',
+  COMMENT: 'you commented',
+};
+
 /** A resolved status that needs no preparation — a skip, a draft, or a retirement. */
 function settled(status: InboxStatus, reason: string): Transition {
   return { status, reason, prepare: false };
diff --git a/packages/cli/src/inbox/store.ts b/packages/cli/src/inbox/store.ts
index 2323d02..02ee803 100644
--- a/packages/cli/src/inbox/store.ts
+++ b/packages/cli/src/inbox/store.ts
@@ -1,7 +1,8 @@
 import { DatabaseSync } from 'node:sqlite';
 import { mkdirSync } from 'node:fs';
 import { dirname } from 'node:path';
-import { ciState, type CiState, type PrSnapshot } from '@diffity/github';
+import { REVIEW_EVENTS, type ReviewEvent } from '@diffity/api';
+import { ciState, type CiState, type PrRef, type PrSnapshot } from '@diffity/github';
 import type { RunStats } from './agent-output.js';
 
 export const INBOX_STATUSES = [
@@ -14,6 +15,7 @@ export const INBOX_STATUSES = [
   'draft',
   'hidden',
   'dismissed',
+  'handled',
   'done',
 ] as const;
 export type InboxStatus = (typeof INBOX_STATUSES)[number];
@@ -71,6 +73,18 @@ export interface Prepared {
   alert: string | null;
 }
 
+/** A review diffity posted to the forge: the head it was posted against, and what it said. */
+export interface Handled {
+  headSha: string;
+  event: ReviewEvent;
+  reviewUrl: string | null;
+  at: string;
+}
+
+export interface HandledMark extends Handled {
+  prId: string;
+}
+
 /** Which agent pass a run was: the drafting one, the one that checks its findings, or an answer. */
 export const RUN_PHASES = ['prepare', 'validate', 'answer'] as const;
 export type RunPhase = (typeof RUN_PHASES)[number];
@@ -158,6 +172,12 @@ export function prId(ref: { owner: string; repo: string; number: number }): stri
   return `${ref.owner}/${ref.repo}#${ref.number}`;
 }
 
+/** A row id back to the ref it names, or null when it does not name one. */
+export function prIdToRef(id: string): PrRef | null {
+  const match = /^([^/]+)\/([^#]+)#(\d+)$/.exec(id);
+  return match ? { owner: match[1], repo: match[2], number: Number(match[3]) } : null;
+}
+
 /**
  * Statuses the inbox is finished with: no poll re-queues them and no surface lists them. A
  * dismissal is not one — it stays listed so the reviewer can take it back with a bump.
@@ -179,6 +199,9 @@ export class InboxStore {
     }
     this.db = new DatabaseSync(path);
     this.db.exec('PRAGMA journal_mode = WAL');
+    // Two processes write here: the daemon's poll and whichever diffity posted a review. Each waits
+    // for the other's write rather than failing on it.
+    this.db.exec('PRAGMA busy_timeout = 5000');
     this.db.exec(`
       CREATE TABLE IF NOT EXISTS inbox_prs (
         id TEXT PRIMARY KEY,
@@ -234,6 +257,17 @@ export class InboxStore {
       )
     `);
     this.db.exec('CREATE INDEX IF NOT EXISTS inbox_runs_pr_started ON inbox_runs (pr_id, started_at)');
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS inbox_handled (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        pr_id TEXT NOT NULL,
+        head_sha TEXT NOT NULL,
+        event TEXT NOT NULL,
+        review_url TEXT,
+        at TEXT NOT NULL
+      )
+    `);
+    this.db.exec('CREATE INDEX IF NOT EXISTS inbox_handled_pr_at ON inbox_handled (pr_id, at)');
     this.db.exec('CREATE TABLE IF NOT EXISTS inbox_state (key TEXT PRIMARY KEY, value TEXT)');
     // A table from an earlier build gains the columns it lacks; a fresh one already has them.
     for (const column of ['attempts INTEGER NOT NULL DEFAULT 0', 'created_at TEXT', 'updated_at TEXT', 'bumped_at TEXT', 'summary TEXT', 'alert TEXT', 'ci_state TEXT']) {
@@ -328,6 +362,38 @@ export class InboxStore {
     `).run(prepared.headSha, prepared.at, prepared.bundlePath, prepared.worktreePath, prepared.logPath, prepared.summary, prepared.alert, id);
   }
 
+  /**
+   * A review diffity posted for a pull request. The log is append-only: a pull request can be
+   * handled at one head and then again at the next.
+   */
+  recordHandled(mark: HandledMark): void {
+    this.db.prepare('INSERT INTO inbox_handled (pr_id, head_sha, event, review_url, at) VALUES (?, ?, ?, ?, ?)')
+      .run(mark.prId, mark.headSha, mark.event, mark.reviewUrl, mark.at);
+  }
+
+  /** The last review posted for a pull request, or null when none was. */
+  latestHandled(prId: string): Handled | null {
+    const row = this.db.prepare(
+      'SELECT head_sha, event, review_url, at FROM inbox_handled WHERE pr_id = ? ORDER BY at DESC, id DESC LIMIT 1',
+    ).get(prId) as unknown as HandledDbRow | undefined;
+    return row
+      ? { headSha: row.head_sha, event: normaliseEvent(row.event), reviewUrl: row.review_url, at: row.at }
+      : null;
+  }
+
+  /**
+   * Pull requests with a posted review that no listed row carries: one the inbox has never seen,
+   * and one it retired as `hidden` before the review reached the forge. A retirement to `done` is
+   * final, so a merged or closed one is not among them.
+   */
+  unadoptedHandledIds(): string[] {
+    return (this.db.prepare(`
+      SELECT DISTINCT pr_id FROM inbox_handled
+      WHERE pr_id NOT IN (SELECT id FROM inbox_prs WHERE status <> 'hidden')
+      ORDER BY pr_id
+    `).all() as unknown as { pr_id: string }[]).map(row => row.pr_id);
+  }
+
   recordRun(run: RunRecord): void {
     this.db.prepare(`
       INSERT INTO inbox_runs (
@@ -465,6 +531,13 @@ function rowToPr(row: Row): InboxPr {
   };
 }
 
+interface HandledDbRow {
+  head_sha: string;
+  event: string;
+  review_url: string | null;
+  at: string;
+}
+
 interface RunDbRow {
   id: number;
   pr_id: string;
@@ -515,6 +588,11 @@ function normaliseCiState(value: string | null): CiState | null {
   return value !== null && CI_STATES.includes(value) ? (value as CiState) : null;
 }
 
+/** A mark from a build that posted other kinds of review still reads as something the reviewer said. */
+function normaliseEvent(value: string): ReviewEvent {
+  return (REVIEW_EVENTS as readonly string[]).includes(value) ? (value as ReviewEvent) : 'COMMENT';
+}
+
 /** A row from a build that knew other statuses is shown as needing work rather than crashing the list. */
 function normaliseStatus(value: string): InboxStatus {
   return (INBOX_STATUSES as readonly string[]).includes(value) ? (value as InboxStatus) : 'queued';
diff --git a/packages/cli/src/inbox/tick.ts b/packages/cli/src/inbox/tick.ts
index 12d2116..bac52e1 100644
--- a/packages/cli/src/inbox/tick.ts
+++ b/packages/cli/src/inbox/tick.ts
@@ -1,7 +1,7 @@
 import type { PrRef, PrSnapshot } from '@diffity/github';
 import { alertForPaths } from './paths-alert.js';
 import { reconcile } from './reconcile.js';
-import { isRetired, prId, runRecordOf, type InboxPr, type InboxStore, type RunOutcome } from './store.js';
+import { isRetired, prId, prIdToRef, runRecordOf, type InboxPr, type InboxStore, type RunOutcome } from './store.js';
 import { localHhMm } from './runs.js';
 import type { PrepareResult } from './prepare.js';
 
@@ -46,8 +46,9 @@ export interface TickDeps {
 
 /**
  * One poll of the forge turned into inbox state: every requested pull request is observed and
- * reconciled, every pull request the inbox already knew but the search no longer lists is retired,
- * and everything the reconcile marked for preparation is prepared, one at a time.
+ * reconciled, every pull request the inbox already knew but the search no longer lists is retired
+ * or listed as handled, every pull request handled from elsewhere is adopted, and everything the
+ * reconcile marked for preparation is prepared, one at a time.
  */
 export async function runTick(store: InboxStore, deps: TickDeps): Promise<void> {
   const viewerLogin = await deps.forge.viewerLogin();
@@ -69,7 +70,10 @@ export async function runTick(store: InboxStore, deps: TickDeps): Promise<void>
     }
     const existing = store.get(prId(ref));
     const pr = store.observe(snapshot, true, deps.now());
-    const transition = reconcile({ existing, snapshot, requested: true, viewerLogin, waitForCi: deps.waitForCi, skipTitles: deps.skipTitles });
+    const transition = reconcile({
+      existing, snapshot, requested: true, viewerLogin, handled: store.latestHandled(pr.id),
+      waitForCi: deps.waitForCi, skipTitles: deps.skipTitles,
+    });
     if (transition) {
       store.setStatus(pr.id, transition.status, transition.reason);
       if (transition.prepare) {
@@ -89,7 +93,7 @@ export async function runTick(store: InboxStore, deps: TickDeps): Promise<void>
       continue;
     }
     store.observe(snapshot, false, deps.now());
-    const transition = reconcile({ existing: pr, snapshot, requested: false, viewerLogin });
+    const transition = reconcile({ existing: pr, snapshot, requested: false, viewerLogin, handled: store.latestHandled(pr.id) });
     if (transition) {
       store.setStatus(pr.id, transition.status, transition.reason);
       if (pr.worktreePath) {
@@ -99,6 +103,30 @@ export async function runTick(store: InboxStore, deps: TickDeps): Promise<void>
     }
   }
 
+  // A review posted from a checkout the inbox never polled — the reviewer's own clone — leaves
+  // nothing behind but its mark, and a row the loop above no longer looks at (retired as `hidden`
+  // before the review was posted) is in the same position. Each is asked about once: the row it
+  // gets is listed, so the loop above has it from the next tick.
+  for (const id of store.unadoptedHandledIds()) {
+    if (requestedIds.has(id) || deps.inFlight.has(id)) {
+      continue;
+    }
+    const ref = prIdToRef(id);
+    if (!ref) {
+      continue;
+    }
+    const snapshot = await deps.forge.viewPr(ref);
+    if (!snapshot) {
+      continue;
+    }
+    const existing = store.get(id);
+    store.observe(snapshot, false, deps.now());
+    const transition = reconcile({ existing, snapshot, requested: false, viewerLogin, handled: store.latestHandled(id) });
+    if (transition) {
+      store.setStatus(id, transition.status, transition.reason);
+    }
+  }
+
   // A pause is the reviewer's Claude limit, not the forge's: the poll above still ran, so the page
   // is current, and only the agent runs wait. The reason goes back on every row held back, because
   // the reconcile above has just cleared it — a queued row reads as plainly queued otherwise.
@@ -189,6 +217,7 @@ export async function prepareBumped(store: InboxStore, deps: TickDeps, id: strin
   // merged or closed while it waited is retired rather than reviewed.
   const transition = reconcile({
     existing, snapshot, requested: snapshot.state === 'OPEN', viewerLogin,
+    handled: store.latestHandled(id),
     waitForCi: deps.waitForCi, skipTitles: deps.skipTitles,
   });
   if (transition) {
diff --git a/packages/cli/src/inbox/view.ts b/packages/cli/src/inbox/view.ts
index 9328cb8..7aa2507 100644
--- a/packages/cli/src/inbox/view.ts
+++ b/packages/cli/src/inbox/view.ts
@@ -1,5 +1,5 @@
 import type { CiState } from '@diffity/github';
-import { isRetired, type InboxPr, type InboxStore, type RunTotals } from './store.js';
+import { isRetired, type Handled, type InboxPr, type InboxStore, type RunTotals } from './store.js';
 import { costOf, minutesOf, runDetail } from './runs.js';
 import { BUMPABLE } from './open.js';
 
@@ -44,6 +44,8 @@ export interface InboxRow {
   bumped: boolean;
   /** What the prepared review cost in agent runs; null when none were recorded for that head. */
   spend: RunSpend | null;
+  /** The last review posted from diffity, and whether the author has pushed since; null when none was. */
+  handled: (Handled & { updated: boolean }) | null;
 }
 
 export interface InboxView {
@@ -51,6 +53,8 @@ export interface InboxView {
   ready: InboxRow[];
   /** Being prepared or waiting to be. */
   working: InboxRow[];
+  /** Reviewed from diffity: kept listed, the ones the author has pushed to since first. */
+  handled: InboxRow[];
   /** Skipped, drafts or failed — shown for the record, with the reason. */
   other: InboxRow[];
   /** Set aside by the reviewer; listed so a bump can bring one back. */
@@ -64,13 +68,36 @@ export interface InboxView {
 
 export function buildView(store: InboxStore, openBase: string, now: string): InboxView {
   const rows = store.all().map(pr => toRow(pr, openBase, store));
-  const ready = rows.filter(row => row.status === 'prepared' || row.status === 'stale')
+  const handled = rows.filter(isHandled).sort(byAttention);
+  const handledIds = new Set(handled.map(row => row.id));
+  const ready = rows.filter(row => (row.status === 'prepared' || row.status === 'stale') && !handledIds.has(row.id))
     .sort((a, b) => diffSize(a) - diffSize(b));
   const working = rows.filter(row => row.status === 'queued' || row.status === 'preparing')
     .sort((a, b) => Number(b.bumped) - Number(a.bumped));
   const dismissed = rows.filter(row => row.status === 'dismissed');
-  const other = rows.filter(row => !ready.includes(row) && !working.includes(row) && !dismissed.includes(row) && !isRetired(row.status));
-  return { ready, working, other, dismissed, generatedAt: now, runs: runWindows(store, now), pausedUntil: store.pausedUntil(now) };
+  const other = rows.filter(row => !ready.includes(row) && !working.includes(row) && !dismissed.includes(row)
+    && !handledIds.has(row.id) && !isRetired(row.status));
+  return { ready, working, handled, other, dismissed, generatedAt: now, runs: runWindows(store, now), pausedUntil: store.pausedUntil(now) };
+}
+
+type HandledRow = InboxRow & { handled: NonNullable<InboxRow['handled']> };
+
+/**
+ * Whether a row belongs in the handled list: the status the last poll settled on, or a prepared
+ * review the reviewer has since posted — the poll after the posting is what turns that one
+ * `handled`, and until then it would otherwise still read as ready to review.
+ */
+function isHandled(row: InboxRow): row is HandledRow {
+  if (row.handled === null) {
+    return false;
+  }
+  return row.status === 'handled'
+    || ((row.status === 'prepared' || row.status === 'stale') && row.handled.at > (row.preparedAt ?? ''));
+}
+
+/** The ones the author has pushed to since the review first, then the most recently reviewed. */
+function byAttention(a: HandledRow, b: HandledRow): number {
+  return Number(b.handled.updated) - Number(a.handled.updated) || b.handled.at.localeCompare(a.handled.at);
 }
 
 /** The two windows the footer shows, on the reviewer's own clock. */
@@ -92,6 +119,7 @@ function spendOf(store: InboxStore, pr: InboxPr): RunSpend | null {
 }
 
 function toRow(pr: InboxPr, openBase: string, store: InboxStore): InboxRow {
+  const handled = store.latestHandled(pr.id);
   const stale = pr.status === 'stale'
     || (pr.status === 'prepared' && pr.preparedHeadSha != null && pr.preparedHeadSha !== pr.headSha);
   const openable = pr.status === 'prepared' || pr.status === 'stale';
@@ -120,6 +148,7 @@ function toRow(pr: InboxPr, openBase: string, store: InboxStore): InboxRow {
     prepareUrl: bumpable && pr.bumpedAt === null ? `${openBase}/prepare/${encodeURIComponent(pr.id)}` : null,
     bumped: pr.bumpedAt !== null,
     spend: spendOf(store, pr),
+    handled: handled === null ? null : { ...handled, updated: handled.headSha !== pr.headSha },
   };
 }
 
diff --git a/packages/cli/src/server.ts b/packages/cli/src/server.ts
index 3e0404f..2f96d48 100644
--- a/packages/cli/src/server.ts
+++ b/packages/cli/src/server.ts
@@ -20,6 +20,7 @@ import {
 } from '@diffity/api';
 import type {
   ClaimResponse,
+  ReviewEvent,
   ReviewSession,
   DiffFileResponse,
   DiffFingerprint,
@@ -84,6 +85,7 @@ import { noteViewerSeen, markViewerGone, viewerSnapshot, viewerIsPresent, viewer
 import { sinceLastWait } from './live-events.js';
 import pc from 'picocolors';
 import { shouldShutDown, IDLE_CHECK_MS } from './idle-shutdown.js';
+import { recordHandledReview } from './inbox/handled.js';
 import { handleReviewRoute } from './review-routes.js';
 import { serializer } from './serialize.js';
 import { handleTourRoute } from './tour-routes.js';
@@ -272,6 +274,27 @@ function refusedDirtyFiles(res: ServerResponse, filePaths: string[]): boolean {
   return true;
 }
 
+/**
+ * Tells the review inbox that this pull request has had its review, so it keeps listing it once
+ * GitHub withdraws the review request. Nothing about the posted review depends on the note landing,
+ * so a store that cannot be written is a warning and no more.
+ */
+function markInboxHandled(
+  remote: { owner: string; repo: string },
+  number: number,
+  headSha: string,
+  event: ReviewEvent,
+  reviewUrl: string,
+): void {
+  try {
+    recordHandledReview({ ...remote, number, headSha, event, reviewUrl, now: new Date().toISOString() });
+  } catch (err) {
+    console.warn(
+      `  Warning: the review was posted, but the inbox could not be told about it: ${err instanceof Error ? err.message : err}`,
+    );
+  }
+}
+
 function descriptionForRef(ref: string): string {
   if (WORKING_TREE_REFS.has(ref)) {
     const labels: Record<string, string> = {
@@ -761,6 +784,11 @@ export function startServer(options: ServerOptions): Promise<ServerResult> {
               details.headSha,
               submission,
             );
+            // Only the reader's own submit counts as the pull request being handled; an agent
+            // posting through this route is not the reviewer having reviewed it.
+            if (result.reviewUrl !== null && req.headers[AGENT_TRAFFIC_HEADER] !== '1') {
+              markInboxHandled(githubRemote, details.prNumber, details.headSha, submission.event, result.reviewUrl);
+            }
             const sentBodies = new Map(submission.comments.map(comment => [comment.threadId, comment.body]));
             const forgeIds = new Map(result.commentIds.map(entry => [entry.threadId, entry.githubCommentId]));
             markThreadsSubmitted(
diff --git a/packages/cli/tests/create-review-handled.test.ts b/packages/cli/tests/create-review-handled.test.ts
new file mode 100644
index 0000000..2b13a14
--- /dev/null
+++ b/packages/cli/tests/create-review-handled.test.ts
@@ -0,0 +1,142 @@
+import { describe, it, expect, beforeAll, afterAll, vi } from 'vitest';
+import { execFileSync } from 'node:child_process';
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, chmodSync } from 'node:fs';
+import { join, delimiter } from 'node:path';
+import { tmpdir } from 'node:os';
+import { AGENT_TRAFFIC_HEADER } from '@diffity/api';
+import { InboxStore } from '../src/inbox/store.js';
+import { inboxStorePath } from '../src/inbox/paths.js';
+
+let root: string;
+let repoDir: string;
+let origCwd: string;
+let origPath: string | undefined;
+let port: number;
+let close: () => void;
+
+/**
+ * A fake gh ahead on PATH that takes a review and answers with the URL GitHub would give it. The
+ * head it reports is the local one, so the server's out-of-sync guard is satisfied.
+ */
+function writeFakeGh(dir: string): void {
+  writeFileSync(join(dir, 'gh'), `#!/bin/sh
+case "$1 $2" in
+  "--version ") echo "gh version 2.0.0"; exit 0 ;;
+  "auth status") exit 0 ;;
+  "pr view")
+    echo "{\\"number\\":1,\\"title\\":\\"A change\\",\\"url\\":\\"https://github.com/o/r/pull/1\\",\\"headRefOid\\":\\"$FAKE_GH_HEAD\\",\\"createdAt\\":\\"2026-01-01T00:00:00Z\\",\\"author\\":{\\"login\\":\\"alice\\"},\\"body\\":\\"\\"}"
+    exit 0 ;;
+  "pr diff") exit 0 ;;
+  "api user") echo "me"; exit 0 ;;
+esac
+if [ "$2" = "repos/o/r/pulls/1/reviews" ] && [ "$3" = "--method" ]; then
+  cat > /dev/null
+  echo '{"html_url":"https://github.com/o/r/pull/1#pullrequestreview-9","id":9}'
+  exit 0
+fi
+if [ "$2" = "repos/o/r/pulls/1/comments" ] && [ "$3" = "--jq" ]; then
+  echo 0
+  exit 0
+fi
+echo "[]"
+exit 0
+`);
+  chmodSync(join(dir, 'gh'), 0o755);
+}
+
+async function postReview(extra: Record<string, string> = {}): Promise<{ status: number; body: { reviewUrl: string | null } }> {
+  const res = await fetch(`http://127.0.0.1:${port}/api/github/create-review`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', 'Sec-Fetch-Site': 'same-origin', ...extra },
+    body: JSON.stringify({ event: 'APPROVE', body: 'Looks good', comments: [] }),
+  });
+  return { status: res.status, body: await res.json() };
+}
+
+beforeAll(async () => {
+  origCwd = process.cwd();
+  root = mkdtempSync(join(tmpdir(), 'diffity-handled-route-'));
+  repoDir = join(root, 'repo');
+  mkdirSync(repoDir);
+
+  execFileSync('git', ['init', '-b', 'main', repoDir], { stdio: 'pipe' });
+  const git = (args: string[]) => execFileSync('git', args, { cwd: repoDir, stdio: 'pipe' });
+  git(['config', 'user.email', 't@t']);
+  git(['config', 'user.name', 'T']);
+  writeFileSync(join(repoDir, 'a.ts'), 'const a = 1;\n');
+  git(['add', '.']);
+  git(['commit', '-m', 'init']);
+  git(['remote', 'add', 'origin', 'https://github.com/o/r.git']);
+  process.env.FAKE_GH_HEAD = execFileSync('git', ['rev-parse', 'HEAD'], { cwd: repoDir, encoding: 'utf-8' }).trim();
+
+  const fakeBin = join(root, 'bin');
+  mkdirSync(fakeBin);
+  writeFakeGh(fakeBin);
+  origPath = process.env.PATH;
+  process.env.PATH = `${fakeBin}${delimiter}${origPath ?? ''}`;
+
+  process.env.DIFFITY_DATA_DIR = join(root, 'notes');
+  process.chdir(repoDir);
+
+  const { startServer } = await import('../src/server.js');
+  const started = await startServer({ port: 0, diffArgs: [], effectiveRef: 'work' });
+  port = started.port;
+  close = started.close;
+});
+
+afterAll(() => {
+  close?.();
+  process.chdir(origCwd);
+  delete process.env.DIFFITY_DATA_DIR;
+  delete process.env.FAKE_GH_HEAD;
+  if (origPath === undefined) {
+    delete process.env.PATH;
+  } else {
+    process.env.PATH = origPath;
+  }
+  rmSync(root, { recursive: true, force: true });
+});
+
+describe('a review posted to GitHub', () => {
+  it('is not marked when an agent posted it rather than the reader', async () => {
+    const { status, body } = await postReview({ [AGENT_TRAFFIC_HEADER]: '1' });
+
+    expect(status).toBe(200);
+    expect(body.reviewUrl).toBe('https://github.com/o/r/pull/1#pullrequestreview-9');
+
+    const store = new InboxStore(inboxStorePath());
+    const handled = store.latestHandled('o/r#1');
+    store.close();
+    expect(handled).toBeNull();
+  }, 15000);
+
+  it('is marked in the inbox, against the head it was posted for', async () => {
+    const { status, body } = await postReview();
+
+    expect(status).toBe(200);
+    expect(body.reviewUrl).toBe('https://github.com/o/r/pull/1#pullrequestreview-9');
+
+    const store = new InboxStore(inboxStorePath());
+    const handled = store.latestHandled('o/r#1');
+    store.close();
+    expect(handled).toMatchObject({
+      headSha: process.env.FAKE_GH_HEAD,
+      event: 'APPROVE',
+      reviewUrl: 'https://github.com/o/r/pull/1#pullrequestreview-9',
+    });
+  }, 15000);
+
+  it('still reaches GitHub when the inbox cannot be written', async () => {
+    // Whatever the reason a mark cannot be kept, the review itself is already the reviewer's word.
+    rmSync(join(root, 'notes', 'inbox'), { recursive: true, force: true });
+    writeFileSync(join(root, 'notes', 'inbox'), 'not a directory\n');
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+    const { status, body } = await postReview();
+
+    expect(status).toBe(200);
+    expect(body.reviewUrl).toBe('https://github.com/o/r/pull/1#pullrequestreview-9');
+    expect(warn).toHaveBeenCalledWith(expect.stringContaining('the inbox could not be told'));
+    warn.mockRestore();
+  }, 15000);
+});
diff --git a/packages/cli/tests/inbox-handled.test.ts b/packages/cli/tests/inbox-handled.test.ts
new file mode 100644
index 0000000..0cc4164
--- /dev/null
+++ b/packages/cli/tests/inbox-handled.test.ts
@@ -0,0 +1,238 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { DatabaseSync } from 'node:sqlite';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { Command } from 'commander';
+import type { PrSnapshot } from '@diffity/github';
+import { recordHandledReview } from '../src/inbox/handled.js';
+import { inboxStorePath } from '../src/inbox/paths.js';
+import { InboxStore, prIdToRef, type HandledMark } from '../src/inbox/store.js';
+import { buildView } from '../src/inbox/view.js';
+import { registerInboxCommand } from '../src/commands/inbox.js';
+
+let dir: string;
+let path: string;
+
+function snapshot(over: Partial<PrSnapshot> = {}): PrSnapshot {
+  return {
+    owner: 'o', repo: 'r', number: 1, title: 'A change', url: 'https://github.com/o/r/pull/1',
+    author: 'alice', isBot: false, isDraft: false, state: 'OPEN', headSha: 'aaa', baseRef: 'main',
+    additions: 10, deletions: 2, changedFiles: 3, createdAt: '2026-09-02T10:00:00Z', updatedAt: '2026-09-02T10:00:00Z',
+    checks: [], files: [], ...over,
+  };
+}
+
+function mark(over: Partial<HandledMark> = {}): HandledMark {
+  return {
+    prId: 'o/r#1', headSha: 'aaa', event: 'APPROVE',
+    reviewUrl: 'https://github.com/o/r/pull/1#pullrequestreview-9',
+    at: '2026-09-08T10:00:00.000Z', ...over,
+  };
+}
+
+beforeEach(() => {
+  dir = mkdtempSync(join(tmpdir(), 'diffity-handled-'));
+  path = join(dir, 'inbox.sqlite');
+});
+
+afterEach(() => {
+  delete process.env.DIFFITY_DATA_DIR;
+  rmSync(dir, { recursive: true, force: true });
+});
+
+describe('the handled log', () => {
+  it('keeps every mark and reads back the latest one per pull request', () => {
+    const store = new InboxStore(path);
+    expect(store.latestHandled('o/r#1')).toBeNull();
+    expect(store.unadoptedHandledIds()).toEqual([]);
+
+    store.recordHandled(mark({ event: 'COMMENT', at: '2026-09-08T09:00:00.000Z' }));
+    store.recordHandled(mark({ headSha: 'bbb', at: '2026-09-08T11:00:00.000Z' }));
+    store.recordHandled(mark({ prId: 'o/r#2', event: 'REQUEST_CHANGES', reviewUrl: null, at: '2026-09-08T10:00:00.000Z' }));
+
+    expect(store.latestHandled('o/r#1')).toEqual({
+      headSha: 'bbb', event: 'APPROVE',
+      reviewUrl: 'https://github.com/o/r/pull/1#pullrequestreview-9', at: '2026-09-08T11:00:00.000Z',
+    });
+    expect(store.latestHandled('o/r#2')?.reviewUrl).toBeNull();
+    expect(store.unadoptedHandledIds()).toEqual(['o/r#1', 'o/r#2']);
+    store.close();
+  });
+
+  it('shows the daemon a mark the posting process wrote while it had the store open', () => {
+    const daemon = new InboxStore(path);
+    expect(daemon.latestHandled('o/r#1')).toBeNull();
+
+    recordHandledReview({
+      owner: 'o', repo: 'r', number: 1, headSha: 'aaa', event: 'REQUEST_CHANGES',
+      reviewUrl: 'https://github.com/o/r/pull/1#pullrequestreview-9',
+      now: '2026-09-08T10:00:00.000Z', storePath: path,
+    });
+
+    expect(daemon.latestHandled('o/r#1')).toEqual({
+      headSha: 'aaa', event: 'REQUEST_CHANGES',
+      reviewUrl: 'https://github.com/o/r/pull/1#pullrequestreview-9', at: '2026-09-08T10:00:00.000Z',
+    });
+    daemon.close();
+  });
+
+  it('writes to the reviewer\'s own inbox when no store is named', () => {
+    process.env.DIFFITY_DATA_DIR = join(dir, 'data');
+
+    recordHandledReview({
+      owner: 'o', repo: 'r', number: 3, headSha: 'ccc', event: 'APPROVE', reviewUrl: null,
+      now: '2026-09-08T10:00:00.000Z',
+    });
+
+    const store = new InboxStore(inboxStorePath());
+    expect(store.unadoptedHandledIds()).toEqual(['o/r#3']);
+    store.close();
+  });
+
+  it('leaves out the marks a listed row already carries, and keeps the hidden ones', () => {
+    const store = new InboxStore(path);
+    for (const number of [1, 2, 3, 4]) {
+      store.observe(snapshot({ number }), false, 'now');
+      store.recordHandled(mark({ prId: `o/r#${number}` }));
+    }
+    store.setStatus('o/r#1', 'handled', 'you approved');
+    store.setStatus('o/r#2', 'hidden', 'review no longer requested');
+    store.setStatus('o/r#3', 'done', 'merged');
+    store.setStatus('o/r#4', 'dismissed', null);
+    store.recordHandled(mark({ prId: 'o/r#5' }));
+
+    // The hidden one is out of the poll's reach, so the adoption pass has to pick it up; a merged
+    // one is done with, and the rest are listed already.
+    expect(store.unadoptedHandledIds()).toEqual(['o/r#2', 'o/r#5']);
+    store.close();
+  });
+
+  it('reads a mark from a build that posted some other kind of review as something said', () => {
+    const seed = new InboxStore(path);
+    seed.close();
+    const raw = new DatabaseSync(path);
+    raw.prepare('INSERT INTO inbox_handled (pr_id, head_sha, event, review_url, at) VALUES (?, ?, ?, ?, ?)')
+      .run('o/r#1', 'aaa', 'DISMISS', null, '2026-09-08T10:00:00.000Z');
+    raw.close();
+
+    const store = new InboxStore(path);
+    expect(store.latestHandled('o/r#1')?.event).toBe('COMMENT');
+    store.close();
+  });
+});
+
+describe('prIdToRef', () => {
+  it('reads a row id back as the ref it names', () => {
+    expect(prIdToRef('NaturalCycles/NCBackend3#14231'))
+      .toEqual({ owner: 'NaturalCycles', repo: 'NCBackend3', number: 14231 });
+    expect(prIdToRef('o/r')).toBeNull();
+    expect(prIdToRef('o/r#x')).toBeNull();
+  });
+});
+
+describe('the handled list', () => {
+  /** A row the daemon has settled as handled, with the mark behind it. */
+  function handledRow(store: InboxStore, over: Partial<PrSnapshot>, over2: Partial<HandledMark> = {}): void {
+    const snap = snapshot(over);
+    store.observe(snap, false, 'now');
+    store.recordHandled(mark({ prId: `o/r#${snap.number}`, ...over2 }));
+    store.setStatus(`o/r#${snap.number}`, 'handled', 'you approved');
+  }
+
+  it('lists a handled row with the mark, and takes it out of the other groups', () => {
+    const store = new InboxStore(':memory:');
+    handledRow(store, {});
+
+    const view = buildView(store, 'http://localhost:5390', 'now');
+    expect(view.handled.map(row => row.id)).toEqual(['o/r#1']);
+    expect(view.other).toEqual([]);
+    expect(view.ready).toEqual([]);
+    expect(view.handled[0].handled).toEqual({
+      headSha: 'aaa', event: 'APPROVE',
+      reviewUrl: 'https://github.com/o/r/pull/1#pullrequestreview-9',
+      at: '2026-09-08T10:00:00.000Z', updated: false,
+    });
+    // Nothing local left to open, but it can be reviewed again or set aside.
+    expect(view.handled[0].openUrl).toBeNull();
+    expect(view.handled[0].prepareUrl).toBe('http://localhost:5390/prepare/o%2Fr%231');
+    expect(view.handled[0].dismissUrl).toBe('http://localhost:5390/dismiss/o%2Fr%231');
+    store.close();
+  });
+
+  it('marks a row the author has pushed to since the review as updated', () => {
+    const store = new InboxStore(':memory:');
+    handledRow(store, { headSha: 'bbb' }, { headSha: 'aaa' });
+
+    expect(buildView(store, 'http://localhost:5390', 'now').handled[0].handled?.updated).toBe(true);
+    store.close();
+  });
+
+  it('takes a prepared review the reviewer has posted out of ready before the next poll', () => {
+    const store = new InboxStore(':memory:');
+    store.observe(snapshot(), true, 'now');
+    store.markPrepared('o/r#1', {
+      headSha: 'aaa', bundlePath: '/b', worktreePath: '/wt', logPath: '/l',
+      at: '2026-09-08T09:00:00.000Z', summary: '1 P2', alert: null,
+    });
+
+    expect(buildView(store, 'http://localhost:5390', 'now').ready.map(row => row.id)).toEqual(['o/r#1']);
+
+    store.recordHandled(mark({ at: '2026-09-08T10:00:00.000Z' }));
+    const view = buildView(store, 'http://localhost:5390', 'now');
+    expect(view.ready).toEqual([]);
+    expect(view.handled.map(row => row.id)).toEqual(['o/r#1']);
+    store.close();
+  });
+
+  it('leaves a review prepared after the last posting in ready', () => {
+    const store = new InboxStore(':memory:');
+    store.observe(snapshot(), true, 'now');
+    store.recordHandled(mark({ at: '2026-09-08T09:00:00.000Z' }));
+    store.markPrepared('o/r#1', {
+      headSha: 'aaa', bundlePath: '/b', worktreePath: '/wt', logPath: '/l',
+      at: '2026-09-08T10:00:00.000Z', summary: '1 P2', alert: null,
+    });
+
+    const view = buildView(store, 'http://localhost:5390', 'now');
+    expect(view.ready.map(row => row.id)).toEqual(['o/r#1']);
+    expect(view.handled).toEqual([]);
+    store.close();
+  });
+
+  it('puts the ones with new commits first, then the most recently reviewed', () => {
+    const store = new InboxStore(':memory:');
+    handledRow(store, { number: 1 }, { at: '2026-09-08T09:00:00.000Z' });
+    handledRow(store, { number: 2 }, { at: '2026-09-08T11:00:00.000Z' });
+    handledRow(store, { number: 3, headSha: 'zzz' }, { at: '2026-09-08T08:00:00.000Z' });
+
+    expect(buildView(store, 'http://localhost:5390', 'now').handled.map(row => row.id))
+      .toEqual(['o/r#3', 'o/r#2', 'o/r#1']);
+    store.close();
+  });
+});
+
+describe('diffity inbox status', () => {
+  it('prints a Handled section with what was said about each one', async () => {
+    process.env.DIFFITY_DATA_DIR = join(dir, 'data');
+    const store = new InboxStore(inboxStorePath());
+    store.observe(snapshot({ headSha: 'bbb' }), false, 'now');
+    store.recordHandled(mark({ headSha: 'aaa' }));
+    store.setStatus('o/r#1', 'handled', 'new commits since you approved');
+    store.close();
+
+    const lines: string[] = [];
+    const log = vi.spyOn(console, 'log').mockImplementation((message: unknown) => { lines.push(String(message)); });
+    const program = new Command();
+    registerInboxCommand(program);
+    await program.parseAsync(['node', 'diffity', 'inbox', 'status']);
+    log.mockRestore();
+
+    const printed = lines.join('\n');
+    expect(printed).toContain('Handled');
+    expect(printed).toContain('updated');
+    expect(printed).toContain('r#1 A change');
+    expect(printed).toContain('new commits since you approved');
+    expect(printed).not.toContain('Nothing in the inbox yet');
+  });
+});
diff --git a/packages/cli/tests/inbox-page.test.ts b/packages/cli/tests/inbox-page.test.ts
index feb8992..c3f61e1 100644
--- a/packages/cli/tests/inbox-page.test.ts
+++ b/packages/cli/tests/inbox-page.test.ts
@@ -120,4 +120,23 @@ describe('the inbox page', () => {
     // extraArgs is not editable here, so it has to travel back untouched.
     expect(script).toContain("extraArgs: (settings.agent && settings.agent.extraArgs) || []");
   });
+
+  it('lists a handled pull request with what was said, linked to GitHub', () => {
+    const html = inboxPage();
+    expect(html).toContain('<h2>Handled</h2>');
+    expect(html).toContain('id="handled"');
+    const script = pageScript();
+    expect(script).toContain("VERDICTS = { APPROVE: 'you approved', REQUEST_CHANGES: 'you requested changes', COMMENT: 'you commented' }");
+    expect(script).toContain("h.updated ? 'new commits since ' + said : said");
+    // No worktree is left to open, so the card is a link to the pull request itself.
+    expect(script).toContain('row.href = r.url;');
+    expect(script).toContain("(h.updated ? 'alert' : 'work')");
+    expect(script).toContain("(h.updated ? 'updated' : 'handled')");
+    // The full sha and the review's own URL are a hover away.
+    expect(script).toContain("'reviewed at ' + h.headSha");
+    expect(script).toContain("fill('handled-section', 'handled', view.handled, r => withActions(handledRow(r), r, REPREPARE_TITLE))");
+    expect(script).toContain("REPREPARE_TITLE = 'Prepare a fresh review of the current head'");
+    // An inbox holding nothing but handled rows is not an empty one.
+    expect(script).toContain('view.handled.length');
+  });
 });
diff --git a/packages/cli/tests/inbox-reconcile.test.ts b/packages/cli/tests/inbox-reconcile.test.ts
index 0152dcf..b5b130a 100644
--- a/packages/cli/tests/inbox-reconcile.test.ts
+++ b/packages/cli/tests/inbox-reconcile.test.ts
@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest';
 import { reconcile, titleSkipReason } from '../src/inbox/reconcile.js';
-import type { InboxPr } from '../src/inbox/store.js';
+import type { Handled, InboxPr } from '../src/inbox/store.js';
 import type { PrCheck, PrSnapshot } from '@diffity/github';
 
 function snapshot(over: Partial<PrSnapshot> = {}): PrSnapshot {
@@ -267,3 +267,87 @@ describe('reconcile with skipTitles', () => {
       .toEqual({ status: 'done', reason: 'merged', prepare: false });
   });
 });
+
+describe('a pull request whose review diffity posted', () => {
+  function handled(over: Partial<Handled> = {}): Handled {
+    return {
+      headSha: 'aaa', event: 'APPROVE',
+      reviewUrl: 'https://github.com/o/r/pull/1#pullrequestreview-9',
+      at: '2026-09-02T12:00:00Z', ...over,
+    };
+  }
+
+  const notRequested = { requested: false, viewerLogin: 'me' } as const;
+
+  it('stays listed as handled instead of being hidden', () => {
+    expect(reconcile({ existing: existing(), snapshot: snapshot(), ...notRequested, handled: handled() }))
+      .toEqual({ status: 'handled', reason: 'you approved', prepare: false });
+  });
+
+  it('says what was said, and whether the author has pushed since', () => {
+    const said = [
+      ['APPROVE', 'you approved'],
+      ['REQUEST_CHANGES', 'you requested changes'],
+      ['COMMENT', 'you commented'],
+    ] as const;
+    for (const [event, phrase] of said) {
+      expect(reconcile({ existing: existing(), snapshot: snapshot(), ...notRequested, handled: handled({ event }) }))
+        .toEqual({ status: 'handled', reason: phrase, prepare: false });
+      expect(reconcile({ existing: existing(), snapshot: snapshot({ headSha: 'bbb' }), ...notRequested, handled: handled({ event }) }))
+        .toEqual({ status: 'handled', reason: `new commits since ${phrase}`, prepare: false });
+    }
+  });
+
+  it('is retired once it is merged or closed', () => {
+    expect(reconcile({ existing: existing(), snapshot: snapshot({ state: 'MERGED' }), ...notRequested, handled: handled() }))
+      .toEqual({ status: 'done', reason: 'merged', prepare: false });
+    expect(reconcile({ existing: existing(), snapshot: snapshot({ state: 'CLOSED' }), ...notRequested, handled: handled() }))
+      .toEqual({ status: 'done', reason: 'closed', prepare: false });
+  });
+
+  it('stays dismissed while its head is unchanged, and comes back when it moves', () => {
+    const dismissed = existing({ status: 'dismissed', headSha: 'aaa' });
+    expect(reconcile({ existing: dismissed, snapshot: snapshot({ headSha: 'aaa' }), ...notRequested, handled: handled() })).toBeNull();
+    expect(reconcile({ existing: dismissed, snapshot: snapshot({ headSha: 'bbb' }), ...notRequested, handled: handled() }))
+      .toEqual({ status: 'handled', reason: 'new commits since you approved', prepare: false });
+  });
+
+  it('leaves a bump\'s preparation to own the row', () => {
+    for (const status of ['queued', 'preparing'] as const) {
+      expect(reconcile({ existing: existing({ status }), snapshot: snapshot(), ...notRequested, handled: handled() })).toBeNull();
+    }
+  });
+
+  it('leaves a review prepared since the posting openable, until that one is posted too', () => {
+    const bumped = existing({ status: 'prepared', preparedAt: '2026-09-02T13:00:00Z' });
+    expect(reconcile({ existing: bumped, snapshot: snapshot(), ...notRequested, handled: handled({ at: '2026-09-02T12:00:00Z' }) })).toBeNull();
+    expect(reconcile({ existing: existing({ status: 'stale', preparedAt: '2026-09-02T13:00:00Z' }), snapshot: snapshot(), ...notRequested, handled: handled({ at: '2026-09-02T12:00:00Z' }) })).toBeNull();
+    expect(reconcile({ existing: bumped, snapshot: snapshot(), ...notRequested, handled: handled({ at: '2026-09-02T14:00:00Z' }) }))
+      .toEqual({ status: 'handled', reason: 'you approved', prepare: false });
+  });
+
+  it('keeps a failed preparation\'s reason until the head moves', () => {
+    const failed = existing({ status: 'failed', statusReason: 'the agent timed out', preparedHeadSha: null, preparedAt: null, headSha: 'aaa' });
+    expect(reconcile({ existing: failed, snapshot: snapshot({ headSha: 'aaa' }), ...notRequested, handled: handled() })).toBeNull();
+    expect(reconcile({ existing: failed, snapshot: snapshot({ headSha: 'bbb' }), ...notRequested, handled: handled() }))
+      .toEqual({ status: 'handled', reason: 'new commits since you approved', prepare: false });
+  });
+
+  it('goes back in the queue when the author asks for another review', () => {
+    const settled = existing({ status: 'handled', statusReason: 'you approved', preparedHeadSha: null, preparedAt: null });
+    expect(reconcile({ existing: settled, snapshot: snapshot({ headSha: 'bbb' }), requested: true, viewerLogin: 'me', handled: handled() }))
+      .toEqual({ status: 'queued', reason: null, prepare: true });
+  });
+
+  it('is skipped by title, and held by CI, like anything else the author asks about again', () => {
+    const settled = existing({ status: 'handled', statusReason: 'you approved', preparedHeadSha: null, preparedAt: null });
+    expect(reconcile({
+      existing: settled, snapshot: snapshot({ headSha: 'bbb', title: 'chore: 1.2.3 Release' }),
+      requested: true, viewerLogin: 'me', handled: handled(), skipTitles: ['Release$'],
+    })).toEqual({ status: 'skipped', reason: 'title matches /Release$/', prepare: false });
+    expect(reconcile({
+      existing: settled, snapshot: snapshot({ headSha: 'bbb', checks: checks(['check-job', 'failure']) }),
+      requested: true, viewerLogin: 'me', handled: handled(), waitForCi: true,
+    })).toEqual({ status: 'skipped', reason: 'CI failed: check-job', prepare: false });
+  });
+});
diff --git a/packages/cli/tests/inbox-tick.test.ts b/packages/cli/tests/inbox-tick.test.ts
index f2b0517..90ad9b8 100644
--- a/packages/cli/tests/inbox-tick.test.ts
+++ b/packages/cli/tests/inbox-tick.test.ts
@@ -33,6 +33,7 @@ class FakeForge implements Forge {
   login: string | null = 'me';
   requested: PrRef[] = [];
   snapshots = new Map<string, PrSnapshot | null>();
+  views: string[] = [];
 
   set(snap: PrSnapshot, listed = true): void {
     this.snapshots.set(prId(snap), snap);
@@ -43,7 +44,10 @@ class FakeForge implements Forge {
 
   viewerLogin() { return Promise.resolve(this.login); }
   searchReviewRequested() { return Promise.resolve(this.requested); }
-  viewPr(ref: PrRef) { return Promise.resolve(this.snapshots.get(prId(ref)) ?? null); }
+  viewPr(ref: PrRef) {
+    this.views.push(prId(ref));
+    return Promise.resolve(this.snapshots.get(prId(ref)) ?? null);
+  }
 }
 
 let store: InboxStore;
@@ -657,3 +661,193 @@ describe('prepareBumped', () => {
     expect(prepared).toEqual([]);
   });
 });
+
+describe('a posted review', () => {
+  /** The tick that follows a review reaching GitHub: the mark is there and the search has dropped it. */
+  async function postAndPoll(at = '2026-09-02T12:30:00.000Z', event: 'APPROVE' | 'COMMENT' = 'APPROVE'): Promise<void> {
+    store.recordHandled({ prId: 'o/r#1', headSha: 'aaa', event, reviewUrl: 'https://github.com/o/r/pull/1#pullrequestreview-9', at });
+    forge.requested = [];
+    await runTick(store, deps());
+  }
+
+  it('keeps the pull request listed, reclaims its worktree once, and follows its head', async () => {
+    forge.set(snapshot());
+    await runTick(store, deps());
+    expect(store.get('o/r#1')!.worktreePath).toBe('/wt/1');
+
+    await postAndPoll();
+    let pr = store.get('o/r#1')!;
+    expect(pr.status).toBe('handled');
+    expect(pr.statusReason).toBe('you approved');
+    expect(removed).toEqual(['/wt/1']);
+    expect(pr.worktreePath).toBeNull();
+
+    // The author pushes: still handled, and the row says the review is behind the head.
+    removed = [];
+    prepared = [];
+    forge.snapshots.set('o/r#1', snapshot({ headSha: 'bbb' }));
+    await runTick(store, deps());
+    pr = store.get('o/r#1')!;
+    expect(pr.status).toBe('handled');
+    expect(pr.statusReason).toBe('new commits since you approved');
+    expect(removed).toEqual([]);
+    expect(prepared).toEqual([]);
+  });
+
+  it('lists it under handled rather than ready or other', async () => {
+    forge.set(snapshot());
+    await runTick(store, deps());
+    await postAndPoll();
+
+    const view = buildView(store, 'http://localhost:5390', '2026-09-02T12:00:00.000Z');
+    expect(view.handled.map(row => row.id)).toEqual(['o/r#1']);
+    expect(view.ready).toEqual([]);
+    expect(view.other).toEqual([]);
+  });
+
+  it('retires it once the pull request is merged', async () => {
+    forge.set(snapshot());
+    await runTick(store, deps());
+    await postAndPoll();
+
+    forge.snapshots.set('o/r#1', snapshot({ state: 'MERGED' }));
+    await runTick(store, deps());
+    expect(store.get('o/r#1')!.status).toBe('done');
+    expect(buildView(store, 'http://localhost:5390', '2026-09-02T12:00:00.000Z').handled).toEqual([]);
+  });
+
+  it('goes back in the queue when the author asks for the review again', async () => {
+    forge.set(snapshot());
+    await runTick(store, deps());
+    await postAndPoll();
+
+    prepared = [];
+    forge.requested = [{ owner: 'o', repo: 'r', number: 1 }];
+    forge.snapshots.set('o/r#1', snapshot({ headSha: 'bbb' }));
+    await runTick(store, deps());
+
+    expect(prepared).toEqual(['o/r#1']);
+    expect(store.get('o/r#1')!.status).toBe('prepared');
+  });
+
+  it('keeps a bumped preparation on a handled row, until that review is posted too', async () => {
+    forge.set(snapshot());
+    await runTick(store, deps());
+    await postAndPoll();
+    expect(store.get('o/r#1')!.status).toBe('handled');
+
+    store.bump('o/r#1', '2026-09-02T13:00:00.000Z');
+    prepared = [];
+    prepareResult = snap => ({
+      kind: 'prepared', headSha: snap.headSha, bundlePath: '/b/1.json', worktree: '/wt/1',
+      logPath: '/l/1.log', at: '2026-09-02T13:05:00.000Z', summary: '1 P2', alert: null,
+      run: run(), validation: 'not-needed', validateRun: null,
+    });
+    await prepareBumped(store, deps(), 'o/r#1');
+    expect(prepared).toEqual(['o/r#1']);
+    expect(store.get('o/r#1')!.status).toBe('prepared');
+
+    // The poll that follows leaves the fresh review where the reviewer can open it.
+    await runTick(store, deps());
+    expect(store.get('o/r#1')!.status).toBe('prepared');
+    expect(buildView(store, 'http://localhost:5390', '2026-09-02T12:00:00.000Z').ready.map(row => row.id)).toEqual(['o/r#1']);
+
+    // Posting that one settles the row again.
+    await postAndPoll('2026-09-02T13:30:00.000Z', 'COMMENT');
+    expect(store.get('o/r#1')!.status).toBe('handled');
+    expect(store.get('o/r#1')!.statusReason).toBe('you commented');
+  });
+
+  it('adopts a pull request the inbox never polled, asking about it once', async () => {
+    store.recordHandled({ prId: 'o/r#7', headSha: 'ggg', event: 'COMMENT', reviewUrl: null, at: '2026-09-02T11:00:00.000Z' });
+    forge.set(snapshot({ number: 7, headSha: 'ggg' }), false);
+
+    await runTick(store, deps());
+    const pr = store.get('o/r#7')!;
+    expect(pr.status).toBe('handled');
+    expect(pr.statusReason).toBe('you commented');
+    expect(prepared).toEqual([]);
+    expect(forge.views).toEqual(['o/r#7']);
+
+    // From here it is an ordinary row: the loop over what the search dropped keeps it current.
+    forge.views = [];
+    forge.snapshots.set('o/r#7', snapshot({ number: 7, headSha: 'hhh' }));
+    await runTick(store, deps());
+    expect(forge.views).toEqual(['o/r#7']);
+    expect(store.get('o/r#7')!.statusReason).toBe('new commits since you commented');
+  });
+
+  it('takes a review posted after the request had already been withdrawn', async () => {
+    forge.set(snapshot());
+    await runTick(store, deps());
+
+    // The request goes away with no review posted: the row is retired and its worktree freed.
+    forge.requested = [];
+    await runTick(store, deps());
+    expect(store.get('o/r#1')!.status).toBe('hidden');
+    expect(store.get('o/r#1')!.worktreePath).toBeNull();
+
+    // The reviewer posts from their own clone afterwards.
+    prepared = [];
+    removed = [];
+    store.recordHandled({ prId: 'o/r#1', headSha: 'aaa', event: 'APPROVE', reviewUrl: null, at: '2026-09-02T13:00:00.000Z' });
+    await runTick(store, deps());
+
+    const pr = store.get('o/r#1')!;
+    expect(pr.status).toBe('handled');
+    expect(pr.statusReason).toBe('you approved');
+    expect(pr.worktreePath).toBeNull();
+    expect(prepared).toEqual([]);
+    expect(removed).toEqual([]);
+    expect(buildView(store, 'http://localhost:5390', '2026-09-02T12:00:00.000Z').handled.map(row => row.id))
+      .toEqual(['o/r#1']);
+  });
+
+  it('leaves a bumped preparation that failed on a handled row saying so', async () => {
+    forge.set(snapshot());
+    await runTick(store, deps());
+    await postAndPoll();
+
+    store.bump('o/r#1', '2026-09-02T13:00:00.000Z');
+    prepareResult = () => ({
+      kind: 'failed', failure: 'timeout', reason: 'the agent timed out',
+      worktree: null, logPath: '/l/1.log', run: run(),
+    });
+    await prepareBumped(store, deps(), 'o/r#1');
+    expect(store.get('o/r#1')!.status).toBe('failed');
+
+    await runTick(store, deps());
+    let pr = store.get('o/r#1')!;
+    expect(pr.status).toBe('failed');
+    expect(pr.statusReason).toBe('the agent timed out');
+
+    // The next push is a new change, and the row goes back to what the posted review said about it.
+    forge.snapshots.set('o/r#1', snapshot({ headSha: 'bbb' }));
+    await runTick(store, deps());
+    pr = store.get('o/r#1')!;
+    expect(pr.status).toBe('handled');
+    expect(pr.statusReason).toBe('new commits since you approved');
+  });
+
+  it('retires an adopted pull request that has since been merged, and asks no more', async () => {
+    store.recordHandled({ prId: 'o/r#8', headSha: 'ggg', event: 'APPROVE', reviewUrl: null, at: '2026-09-02T11:00:00.000Z' });
+    forge.set(snapshot({ number: 8, state: 'MERGED' }), false);
+
+    await runTick(store, deps());
+    expect(store.get('o/r#8')!.status).toBe('done');
+
+    forge.views = [];
+    await runTick(store, deps());
+    expect(forge.views).toEqual([]);
+  });
+
+  it('leaves a mark the forge knows nothing about alone', async () => {
+    store.recordHandled({ prId: 'o/r#9', headSha: 'ggg', event: 'APPROVE', reviewUrl: null, at: '2026-09-02T11:00:00.000Z' });
+    store.recordHandled({ prId: 'not-a-pull-request', headSha: 'ggg', event: 'APPROVE', reviewUrl: null, at: '2026-09-02T11:00:00.000Z' });
+
+    await runTick(store, deps());
+
+    expect(store.get('o/r#9')).toBeNull();
+    expect(forge.views).toEqual(['o/r#9']);
+  });
+});
diff --git a/packages/git/package.json b/packages/git/package.json
index 14175b5..1b99e40 100644
--- a/packages/git/package.json
+++ b/packages/git/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@diffity/git",
-  "version": "0.10.28",
+  "version": "0.10.29",
   "private": true,
   "type": "module",
   "main": "./dist/index.js",
diff --git a/packages/github/package.json b/packages/github/package.json
index 7df2da9..4bf8822 100644
--- a/packages/github/package.json
+++ b/packages/github/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@diffity/github",
-  "version": "0.10.28",
+  "version": "0.10.29",
   "private": true,
   "type": "module",
   "main": "./dist/index.js",
diff --git a/packages/parser/package.json b/packages/parser/package.json
index 4f56a0f..7cffdaf 100644
--- a/packages/parser/package.json
+++ b/packages/parser/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@diffity/parser",
-  "version": "0.10.28",
+  "version": "0.10.29",
   "private": true,
   "type": "module",
   "main": "./dist/index.js",
diff --git a/packages/ui/package.json b/packages/ui/package.json
index b622c23..87d7404 100644
--- a/packages/ui/package.json
+++ b/packages/ui/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@diffity/ui",
-  "version": "0.10.28",
+  "version": "0.10.29",
   "type": "module",
   "private": true,
   "scripts": {