@d3lm/pr-stats 0.2.21 → 0.2.23

package/dist/tui-app.mjs

@@ -136,10 +136,10 @@ import { createRoot } from "@opentui/react";
 
 // src/tui/App.tsx
 import { useKeyboard, useRenderer as useRenderer3, useTerminalDimensions as useTerminalDimensions3 } from "@opentui/react";
-import { useEffect as useEffect8, useMemo as useMemo2, useReducer, useRef as useRef6, useState as useState5 } from "react";
+import { useEffect as useEffect8, useMemo as useMemo2, useReducer, useRef as useRef8, useState as useState6 } from "react";
 
-// src/settings.ts
-import { readFileSync as readFileSync3, rmSync as rmSync2 } from "node:fs";
+// src/mentions.ts
+import { readFileSync as readFileSync3 } from "node:fs";
 import { join as join3 } from "node:path";
 
 // src/cache.ts
@@ -166,7 +166,7 @@ function cacheDir() {
 function prKey(repo, number) {
   return `${repo}#${number}`;
 }
-var CACHE_FILES = ["details", "sizes", "user", "snapshot"];
+var CACHE_FILES = ["details", "sizes", "mentions", "user", "snapshot", "mention-baseline"];
 function clearCache() {
   if (!enabled) {
     return false;
@@ -283,6 +283,9 @@ function percentile(sorted, percent) {
 }
 
 // src/snooze.ts
+function snoozeMatches(snooze, target) {
+  return snooze.kind === target.kind && snooze.ref === target.ref;
+}
 var DEFAULT_SNOOZE_DURATION = "30m";
 var MINUTE_MS = 6e4;
 var HOUR_MS = 60 * MINUTE_MS;
@@ -315,20 +318,33 @@ function formatWakeTime(until, now = Date.now()) {
 function snoozesFile() {
   return join2(cacheDir(), "snoozes.json");
 }
-function reviveSnooze(ref, stored) {
+function parseStoredKey(key) {
+  for (const kind of ["review", "mention"]) {
+    if (key.startsWith(`${kind}:`)) {
+      return { kind, ref: key.slice(kind.length + 1) };
+    }
+  }
+  return { kind: "review", ref: key };
+}
+function reviveSnooze(key, stored) {
   if (typeof stored !== "object" || stored === null) {
     return null;
   }
-  const { until, requestedAt } = stored;
-  if (typeof until !== "string" || typeof requestedAt !== "string") {
+  const { until, at, requestedAt, ids } = stored;
+  const askedAt = at ?? requestedAt;
+  if (typeof until !== "string" || typeof askedAt !== "string") {
     return null;
   }
   const untilMs = Date.parse(until);
-  const requestedAtMs = Date.parse(requestedAt);
-  if (Number.isNaN(untilMs) || Number.isNaN(requestedAtMs)) {
+  const atMs = Date.parse(askedAt);
+  if (Number.isNaN(untilMs) || Number.isNaN(atMs)) {
     return null;
   }
-  return { ref, until: untilMs, requestedAt: requestedAtMs };
+  const snooze = { ...parseStoredKey(key), until: untilMs, at: atMs };
+  if (Array.isArray(ids)) {
+    snooze.ids = ids.filter((id) => typeof id === "string");
+  }
+  return snooze;
 }
 function readSnoozes() {
   if (!cacheEnabled()) {
@@ -344,8 +360,8 @@ function readSnoozes() {
     return [];
   }
   const snoozes2 = [];
-  for (const [ref, stored] of Object.entries(parsed)) {
-    const snooze = reviveSnooze(ref, stored);
+  for (const [key, stored] of Object.entries(parsed)) {
+    const snooze = reviveSnooze(key, stored);
     if (snooze !== null) {
       snoozes2.push(snooze);
     }
@@ -358,25 +374,25 @@ function writeSnoozes(snoozes2) {
   }
   const stored = {};
   for (const snooze of snoozes2) {
-    stored[snooze.ref] = {
+    stored[`${snooze.kind}:${snooze.ref}`] = {
       until: new Date(snooze.until).toISOString(),
-      requestedAt: new Date(snooze.requestedAt).toISOString()
+      at: new Date(snooze.at).toISOString(),
+      ...snooze.ids === void 0 ? {} : { ids: [...snooze.ids] }
     };
   }
   writeFileAtomic(snoozesFile(), `${JSON.stringify(stored, null, 2)}
 `);
   return true;
 }
-function activeSnooze(snoozes2, ref, requestedAt, now) {
-  return snoozes2.find(
-    (snooze) => snooze.ref === ref && snooze.until > now && requestedAt.getTime() <= snooze.requestedAt
-  );
+function findSnooze(snoozes2, target, now, covers) {
+  return snoozes2.find((snooze) => snoozeMatches(snooze, target) && snooze.until > now && covers(snooze));
 }
-function splitSnoozed(entries, snoozes2, now) {
+function partitionSnoozed(kind, entries, snoozes2, now, covers) {
   const awaiting = [];
   const snoozed = [];
   for (const entry of entries) {
-    const snooze = activeSnooze(snoozes2, prKey(entry.pr.repo, entry.pr.number), entry.requestedAt, now);
+    const target = { kind, ref: prKey(entry.pr.repo, entry.pr.number) };
+    const snooze = findSnooze(snoozes2, target, now, (candidate) => covers(candidate, entry));
     if (snooze === void 0) {
       awaiting.push(entry);
     } else {
@@ -386,6 +402,9 @@ function splitSnoozed(entries, snoozes2, now) {
   snoozed.sort((a, b) => a.until - b.until);
   return { awaiting, snoozed };
 }
+function splitSnoozed(entries, snoozes2, now) {
+  return partitionSnoozed("review", entries, snoozes2, now, (snooze, entry) => entry.requestedAt.getTime() <= snooze.at);
+}
 function nextWakeUp(snoozes2) {
   if (snoozes2.length === 0) {
     return null;
@@ -406,12 +425,181 @@ function wokenPrs(due, results) {
     }
   }
   return due.flatMap((snooze) => {
+    if (snooze.kind !== "review") {
+      return [];
+    }
     const entry = pending.get(snooze.ref);
-    return entry !== void 0 && entry.requestedAt <= snooze.requestedAt ? [entry.pr] : [];
+    return entry !== void 0 && entry.requestedAt <= snooze.at ? [entry.pr] : [];
   });
 }
 
+// src/mentions.ts
+function emptyMentionReads() {
+  return { seed: null, reads: /* @__PURE__ */ new Map() };
+}
+function mentionIdsOf(entry) {
+  return [...(entry.mentions ?? []).map((mention) => mention.id), ...entry.earlier];
+}
+function mentionItems(entries) {
+  const items = [];
+  for (const entry of entries) {
+    if (entry.mentions === null || entry.mentions.length === 0) {
+      continue;
+    }
+    items.push({
+      pr: entry.pr,
+      mentionedAt: Math.max(...entry.mentions.map((mention) => mention.at.getTime())),
+      mentions: entry.mentions,
+      ids: mentionIdsOf(entry)
+    });
+  }
+  return items;
+}
+function markOf(item) {
+  return { at: item.mentionedAt, ids: item.ids };
+}
+function hasNewMention(item, mark) {
+  return item.mentions.some((mention) => mention.at.getTime() > mark.at && !mark.ids.includes(mention.id));
+}
+function isUnreadMention(reads, item) {
+  const mark = reads.reads.get(prKey(item.pr.repo, item.pr.number));
+  if (mark === null) {
+    return true;
+  }
+  if (mark !== void 0) {
+    return hasNewMention(item, mark);
+  }
+  return reads.seed !== null && hasNewMention(item, reads.seed);
+}
+function seedMentionReads(reads, seed) {
+  return reads.seed === null ? { ...reads, seed } : reads;
+}
+function unseedMentionReads(reads) {
+  return reads.seed === null ? reads : { ...reads, seed: null };
+}
+function markMentionRead(reads, ref, mark) {
+  return { ...reads, reads: new Map(reads.reads).set(ref, mark) };
+}
+function markMentionUnread(reads, ref) {
+  return { ...reads, reads: new Map(reads.reads).set(ref, null) };
+}
+function snoozeMark(snooze) {
+  return { at: snooze.at, ids: snooze.ids ?? [] };
+}
+function splitMentions(items, reads, snoozes2, now) {
+  const read = [];
+  const pending = [];
+  for (const item of items) {
+    (isUnreadMention(reads, item) ? pending : read).push(item);
+  }
+  const { awaiting, snoozed } = partitionSnoozed(
+    "mention",
+    pending,
+    snoozes2,
+    now,
+    (snooze, item) => !hasNewMention(item, snoozeMark(snooze))
+  );
+  return { unread: awaiting.toSorted(byNewestMention), snoozed, read: read.toSorted(byNewestMention) };
+}
+function byNewestMention(a, b) {
+  return b.mentionedAt - a.mentionedAt;
+}
+function wokenMentions(due, entries, reads) {
+  const items = /* @__PURE__ */ new Map();
+  for (const item of mentionItems(entries)) {
+    items.set(prKey(item.pr.repo, item.pr.number), item);
+  }
+  return due.flatMap((snooze) => {
+    if (snooze.kind !== "mention") {
+      return [];
+    }
+    const item = items.get(snooze.ref);
+    return item !== void 0 && !hasNewMention(item, snoozeMark(snooze)) && isUnreadMention(reads, item) ? [item.pr] : [];
+  });
+}
+function mentionReadsFile() {
+  return join3(cacheDir(), "mention-reads.json");
+}
+function reviveMark(stored) {
+  if (typeof stored !== "object" || stored === null || Array.isArray(stored)) {
+    return void 0;
+  }
+  const { at, ids } = stored;
+  if (typeof at !== "string" || !Array.isArray(ids)) {
+    return void 0;
+  }
+  const ms = Date.parse(at);
+  return Number.isNaN(ms) ? void 0 : { at: ms, ids: ids.filter((id) => typeof id === "string") };
+}
+function reviveReads(stored) {
+  if (typeof stored !== "object" || stored === null || Array.isArray(stored)) {
+    return void 0;
+  }
+  const { seed, reads: marks } = stored;
+  const reads = /* @__PURE__ */ new Map();
+  if (typeof marks === "object" && marks !== null && !Array.isArray(marks)) {
+    for (const [ref, mark] of Object.entries(marks)) {
+      if (mark === null) {
+        reads.set(ref, null);
+      } else {
+        const revived = reviveMark(mark);
+        if (revived !== void 0) {
+          reads.set(ref, revived);
+        }
+      }
+    }
+  }
+  return { seed: reviveMark(seed) ?? null, reads };
+}
+function readMentionReads() {
+  const all = /* @__PURE__ */ new Map();
+  if (!cacheEnabled()) {
+    return all;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync3(mentionReadsFile(), "utf8"));
+  } catch {
+    return all;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return all;
+  }
+  const { users } = parsed;
+  if (typeof users !== "object" || users === null || Array.isArray(users)) {
+    return all;
+  }
+  for (const [login, stored] of Object.entries(users)) {
+    const reads = reviveReads(stored);
+    if (reads !== void 0) {
+      all.set(login.toLowerCase(), reads);
+    }
+  }
+  return all;
+}
+function storeMark(mark) {
+  return { at: new Date(mark.at).toISOString(), ids: [...mark.ids] };
+}
+function writeMentionReads(all) {
+  if (!cacheEnabled()) {
+    return false;
+  }
+  const stored = { users: {} };
+  for (const [login, reads] of all) {
+    const marks = {};
+    for (const [ref, mark] of reads.reads) {
+      marks[ref] = mark === null ? null : storeMark(mark);
+    }
+    stored.users[login] = { seed: reads.seed === null ? null : storeMark(reads.seed), reads: marks };
+  }
+  writeFileAtomic(mentionReadsFile(), `${JSON.stringify(stored, null, 2)}
+`);
+  return true;
+}
+
 // src/settings.ts
+import { readFileSync as readFileSync4, rmSync as rmSync2 } from "node:fs";
+import { join as join4 } from "node:path";
 var NOTIFY_CHANNELS = ["auto", "terminal", "command", "bell"];
 var DEFAULT_RELOAD_INTERVAL = "10m";
 var MAX_RELOAD_INTERVAL_MS = 24 * 60 * 60 * 1e3;
@@ -431,7 +619,7 @@ function parseReloadInterval(input) {
   return ms;
 }
 function settingsFile() {
-  return join3(cacheDir(), "settings.json");
+  return join4(cacheDir(), "settings.json");
 }
 var current = {};
 function writeCurrent() {
@@ -449,7 +637,7 @@ function loadSettings() {
   }
   let text;
   try {
-    text = readFileSync3(settingsFile(), "utf8");
+    text = readFileSync4(settingsFile(), "utf8");
   } catch {
     return current;
   }
@@ -480,6 +668,12 @@ function loadSettings() {
   if (settings.notifications !== void 0 && typeof settings.notifications !== "boolean") {
     throw new CliError(`"notifications" in ${settingsFile()} must be true or false`);
   }
+  if (settings.trackMentions !== void 0 && typeof settings.trackMentions !== "boolean") {
+    throw new CliError(`"trackMentions" in ${settingsFile()} must be true or false`);
+  }
+  if (settings.notifyMentions !== void 0 && typeof settings.notifyMentions !== "boolean") {
+    throw new CliError(`"notifyMentions" in ${settingsFile()} must be true or false`);
+  }
   if (settings.notifyChannel !== void 0 && !NOTIFY_CHANNELS.includes(settings.notifyChannel)) {
     throw new CliError(`"notifyChannel" in ${settingsFile()} must be "auto", "terminal", "command", or "bell"`);
   }
@@ -511,6 +705,14 @@ function saveNotifications(on) {
   current = { ...current, notifications: on };
   return writeCurrent();
 }
+function saveTrackMentions(on) {
+  current = { ...current, trackMentions: on };
+  return writeCurrent();
+}
+function saveNotifyMentions(on) {
+  current = { ...current, notifyMentions: on };
+  return writeCurrent();
+}
 function saveNotifyChannel(channel) {
   current = { ...current, notifyChannel: channel };
   return writeCurrent();
@@ -544,6 +746,124 @@ function applySettings(values, explicit) {
   return settings;
 }
 
+// src/tui/state/browse.ts
+var TABS = ["1 Awaiting you", "2 Your PRs", "3 Reviews", "4 PR size", "5 Comments"];
+var PENDING_SUB_TABS = [
+  { key: "pending", label: "Awaiting review" },
+  { key: "reviewed", label: "Reviewed" },
+  { key: "mentions", label: "Mentions" }
+];
+var AUTHORED_SUB_TABS = [
+  { key: "open", label: "Open" },
+  { key: "merged", label: "Merged & closed" }
+];
+function cycledPendingSubTab(current2, delta) {
+  const index = PENDING_SUB_TABS.findIndex((entry) => entry.key === current2);
+  return PENDING_SUB_TABS[(index + PENDING_SUB_TABS.length + delta) % PENDING_SUB_TABS.length];
+}
+var initialBrowseState = {
+  tab: 0,
+  pendingTab: "pending",
+  authoredTab: "open",
+  scopes: {
+    pending: { view: "list" },
+    reviewed: { view: "list" },
+    mentions: { view: "list" },
+    open: { view: "list" },
+    review: { view: "list" },
+    size: { view: "list" },
+    comment: { view: "list" },
+    merged: { view: "list" }
+  },
+  repoCursors: { pending: 0, reviewed: 0, mentions: 0, open: 0, review: 0, size: 0, comment: 0, merged: 0 },
+  rowCursors: { pending: 0, reviewed: 0, mentions: 0, open: 0 },
+  grouped: { pending: false, reviewed: false, mentions: false, open: false },
+  expanded: { review: false, size: false, comment: false, merged: false }
+};
+function activeQueueTab(state) {
+  if (state.tab === 0) {
+    return state.pendingTab;
+  }
+  if (state.tab === 1 && state.authoredTab === "open") {
+    return "open";
+  }
+  return null;
+}
+function dropVanishedRepo(scope, repos) {
+  if (scope.view === "detail" && scope.repo !== null && !repos.some((option) => option.repo === scope.repo)) {
+    return { view: "list" };
+  }
+  return scope;
+}
+function cycled(previous, delta, count2) {
+  return (Math.min(previous, count2 - 1) + count2 + delta) % count2;
+}
+function browseReducer(state, action) {
+  switch (action.type) {
+    case "tabSelected": {
+      return { ...state, tab: action.tab };
+    }
+    case "tabCycled": {
+      return { ...state, tab: (state.tab + TABS.length + action.delta) % TABS.length };
+    }
+    case "subTabCycled": {
+      if (state.tab === 0) {
+        return { ...state, pendingTab: cycledPendingSubTab(state.pendingTab, action.delta).key };
+      }
+      if (state.tab === 1) {
+        return { ...state, authoredTab: state.authoredTab === "open" ? "merged" : "open" };
+      }
+      return state;
+    }
+    case "repoCursorMoved": {
+      return {
+        ...state,
+        repoCursors: {
+          ...state.repoCursors,
+          [action.tab]: cycled(state.repoCursors[action.tab], action.delta, action.count)
+        }
+      };
+    }
+    case "rowCursorMoved": {
+      return {
+        ...state,
+        rowCursors: {
+          ...state.rowCursors,
+          [action.tab]: cycled(state.rowCursors[action.tab], action.delta, action.count)
+        }
+      };
+    }
+    case "repoOpened": {
+      return { ...state, scopes: { ...state.scopes, [action.tab]: { view: "detail", repo: action.repo } } };
+    }
+    case "pickerReturned": {
+      return { ...state, scopes: { ...state.scopes, [action.tab]: { view: "list" } } };
+    }
+    case "groupingToggled": {
+      return { ...state, grouped: { ...state.grouped, [action.tab]: !state.grouped[action.tab] } };
+    }
+    case "expandToggled": {
+      return { ...state, expanded: { ...state.expanded, [action.tab]: !state.expanded[action.tab] } };
+    }
+    case "dataLoaded": {
+      return {
+        ...state,
+        scopes: {
+          pending: dropVanishedRepo(state.scopes.pending, action.repos.pending),
+          reviewed: dropVanishedRepo(state.scopes.reviewed, action.repos.reviewed),
+          mentions: dropVanishedRepo(state.scopes.mentions, action.repos.mentions),
+          open: dropVanishedRepo(state.scopes.open, action.repos.open),
+          review: dropVanishedRepo(state.scopes.review, action.repos.review),
+          size: dropVanishedRepo(state.scopes.size, action.repos.size),
+          comment: dropVanishedRepo(state.scopes.comment, action.repos.comment),
+          merged: dropVanishedRepo(state.scopes.merged, action.repos.merged)
+        }
+      };
+    }
+  }
+  return state;
+}
+
 // src/tui/theme.ts
 var BASE = {
   bg: "#1e1e1e",
@@ -837,26 +1157,23 @@ function durationHours(start, end) {
 }
 
 // src/compute.ts
-function computeReviewStats(results, { targetHours, now = /* @__PURE__ */ new Date() } = {}) {
-  const reviewed = [];
+function pendingRequests(results) {
   const pending = [];
   for (const result of results) {
-    if (result.kind === "reviewed") {
-      reviewed.push({
-        pr: result.pr,
-        requestedAt: result.requestedAt,
-        reviewedAt: result.reviewedAt,
-        hours: durationHours(result.requestedAt, result.reviewedAt),
-        verdict: result.verdict,
-        lines: result.lines
-      });
-    } else if (result.kind === "pending" && result.pr.state === "open") {
-      pending.push({ pr: result.pr, requestedAt: result.requestedAt, hours: durationHours(result.requestedAt, now) });
+    if (result.kind === "pending" && result.pr.state === "open") {
+      pending.push({ pr: result.pr, requestedAt: result.requestedAt });
     }
   }
-  pending.sort((a, b) => a.requestedAt.getTime() - b.requestedAt.getTime());
-  const pendingKeys = new Set(pending.map((entry) => `${entry.pr.repo}#${entry.pr.number}`));
-  const latestReviews = /* @__PURE__ */ new Map();
+  return pending.toSorted((a, b) => a.requestedAt.getTime() - b.requestedAt.getTime());
+}
+function latestReviews(results) {
+  const pendingKeys = /* @__PURE__ */ new Set();
+  for (const result of results) {
+    if (result.kind === "pending" && result.pr.state === "open") {
+      pendingKeys.add(`${result.pr.repo}#${result.pr.number}`);
+    }
+  }
+  const latest = /* @__PURE__ */ new Map();
   for (const result of results) {
     if (result.kind !== "reviewed" && result.kind !== "unrequested" || result.pr.state !== "open") {
       continue;
@@ -865,14 +1182,33 @@ function computeReviewStats(results, { targetHours, now = /* @__PURE__ */ new Da
     if (pendingKeys.has(key)) {
       continue;
     }
-    const latest = latestReviews.get(key);
-    if (latest === void 0 || result.reviewedAt > latest.reviewedAt) {
-      latestReviews.set(key, { pr: result.pr, reviewedAt: result.reviewedAt });
+    const known = latest.get(key);
+    if (known === void 0 || result.reviewedAt > known.reviewedAt) {
+      latest.set(key, { pr: result.pr, reviewedAt: result.reviewedAt });
+    }
+  }
+  return [...latest.values()].toSorted((a, b) => a.reviewedAt.getTime() - b.reviewedAt.getTime());
+}
+function computeReviewStats(results, { targetHours, now = /* @__PURE__ */ new Date() } = {}) {
+  const reviewed = [];
+  for (const result of results) {
+    if (result.kind === "reviewed") {
+      reviewed.push({
+        pr: result.pr,
+        requestedAt: result.requestedAt,
+        reviewedAt: result.reviewedAt,
+        hours: durationHours(result.requestedAt, result.reviewedAt),
+        verdict: result.verdict,
+        lines: result.lines
+      });
     }
   }
-  const reviewing = [...latestReviews.values()].map(({ pr, reviewedAt }) => {
-    return { pr, reviewedAt, hours: durationHours(reviewedAt, now) };
-  }).toSorted((a, b) => a.reviewedAt.getTime() - b.reviewedAt.getTime());
+  const pending = pendingRequests(results).map((entry) => {
+    return { ...entry, hours: durationHours(entry.requestedAt, now) };
+  });
+  const reviewing = latestReviews(results).map((entry) => {
+    return { ...entry, hours: durationHours(entry.reviewedAt, now) };
+  });
   const expired = results.filter((result) => result.kind === "pending" && result.pr.state !== "open");
   const unrequested = results.filter((result) => result.kind === "unrequested");
   const allHours = reviewed.map((result) => result.hours);
@@ -1125,12 +1461,24 @@ function queueRowAt(view, cursor) {
   return rows[Math.min(cursor, rows.length - 1)];
 }
 function snoozeActionOf(row) {
-  if (row?.pending === void 0) {
+  if (row?.pending !== void 0) {
+    return row.pending.snoozed ? "unsnooze" : "snooze";
+  }
+  if (row?.mention === void 0 || row.mention.state === "read") {
+    return null;
+  }
+  return row.mention.state === "snoozed" ? "unsnooze" : "snooze";
+}
+function mentionActionOf(row) {
+  if (row?.mention === void 0) {
     return null;
   }
-  return row.pending.snoozed ? "unsnooze" : "snooze";
+  return row.mention.state === "read" ? "unread" : "read";
 }
-function groupedLists(entries, rowsOf2) {
+function unreadMentionRows(view) {
+  return view === null ? [] : queueRows(view).filter((row) => row.mention?.state === "unread");
+}
+function groupedLists(entries, rowsOf) {
   const groups = /* @__PURE__ */ new Map();
   for (const entry of entries) {
     const group = groups.get(entry.pr.repo) ?? [];
@@ -1138,40 +1486,108 @@ function groupedLists(entries, rowsOf2) {
     groups.set(entry.pr.repo, group);
   }
   return [...groups.entries()].toSorted((a, b) => b[1].length - a[1].length || a[0].localeCompare(b[0])).map(([repo, group]) => {
-    return { title: `${repo} (n=${group.length})`, rows: rowsOf2(group) };
+    return { title: `${repo} (n=${group.length})`, rows: rowsOf(group) };
   });
 }
-function buildPendingReviewView(raw, repo = null, grouped = false, snoozes2 = [], now = Date.now()) {
-  const stats = computeReviewStats(raw.reviewResults, { now: raw.fetchedAt });
-  const inScope = (entries) => repo === null ? entries : entries.filter((entry) => entry.pr.repo === repo);
-  const { awaiting, snoozed } = splitSnoozed(inScope(stats.pending), snoozes2, now);
-  const reviewing = inScope(stats.reviewing);
-  if (awaiting.length === 0 && snoozed.length === 0 && reviewing.length === 0) {
-    return { empty: "No PRs are awaiting your review, and none you reviewed are still open.", sections: [] };
+function inScopeOf(entries, repo) {
+  return repo === null ? entries : entries.filter((entry) => entry.pr.repo === repo);
+}
+function sectionOf(title, entries, rowsOf, split) {
+  return split ? { title, rows: [], lists: groupedLists(entries, rowsOf) } : { title, rows: rowsOf(entries), lists: [] };
+}
+function unreadMentionRefs(raw, snoozes2, reads, now) {
+  const { unread } = splitMentions(mentionItems(raw.mentions ?? []), reads, snoozes2, now);
+  return new Set(unread.map((item) => prKey(item.pr.repo, item.pr.number)));
+}
+function queueAlerts(raw, snoozes2 = [], reads = emptyMentionReads(), now = Date.now()) {
+  const { awaiting } = splitSnoozed(pendingRequests(raw.reviewResults), snoozes2, now);
+  const { unread } = splitMentions(mentionItems(raw.mentions ?? []), reads, snoozes2, now);
+  return { pending: awaiting.length > 0, mentions: unread.length > 0 };
+}
+function buildPendingReviewView(raw, repo = null, grouped = false, snoozes2 = [], reads = emptyMentionReads(), now = Date.now()) {
+  const { awaiting, snoozed } = splitSnoozed(inScopeOf(pendingRequests(raw.reviewResults), repo), snoozes2, now);
+  if (awaiting.length === 0 && snoozed.length === 0) {
+    return { empty: "No PRs are awaiting your review.", sections: [] };
   }
   const split = repo === null && grouped;
-  const sectionOf = (title, entries, rowsOf2) => split ? { title, rows: [], lists: groupedLists(entries, rowsOf2) } : { title, rows: rowsOf2(entries), lists: [] };
-  const snoozedRowsOf = (group) => snoozedRows(group, now);
+  const mentioned = unreadMentionRefs(raw, snoozes2, reads, now);
+  const awaitingRowsOf = (group) => waitRows(group, (entry) => entry.requestedAt, raw.fetchedAt).map((row, i) => {
+    return {
+      ...row,
+      pending: { requestedAt: group[i].requestedAt.getTime(), snoozed: false },
+      ...badgeOf(row, mentioned)
+    };
+  });
+  const snoozedRowsOf = (group) => wakeRows(group, now).map((row, i) => {
+    return {
+      ...row,
+      pending: { requestedAt: group[i].requestedAt.getTime(), snoozed: true },
+      ...badgeOf(row, mentioned)
+    };
+  });
   return {
     empty: null,
     sections: [
-      ...awaiting.length === 0 ? [] : [sectionOf(`Awaiting your review (n=${awaiting.length})`, awaiting, awaitingRows)],
-      ...snoozed.length === 0 ? [] : [sectionOf(`Snoozed (n=${snoozed.length})`, snoozed, snoozedRowsOf)],
-      ...reviewing.length === 0 ? [] : [sectionOf(`Reviewed (n=${reviewing.length})`, reviewing, rowsOf)]
+      ...awaiting.length === 0 ? [] : [sectionOf(`Awaiting your review (n=${awaiting.length})`, awaiting, awaitingRowsOf, split)],
+      ...snoozed.length === 0 ? [] : [sectionOf(`Snoozed (n=${snoozed.length})`, snoozed, snoozedRowsOf, split)]
     ]
   };
 }
-function awaitingRows(group) {
-  return rowsOf(group).map((row, i) => {
-    return { ...row, pending: { requestedAt: group[i].requestedAt.getTime(), snoozed: false } };
+function buildReviewedView(raw, repo = null, grouped = false, snoozes2 = [], reads = emptyMentionReads(), now = Date.now()) {
+  const reviewing = inScopeOf(latestReviews(raw.reviewResults), repo);
+  if (reviewing.length === 0) {
+    return { empty: "No PRs you reviewed are still open.", sections: [] };
+  }
+  const mentioned = unreadMentionRefs(raw, snoozes2, reads, now);
+  const reviewedRowsOf = (group) => waitRows(group, (entry) => entry.reviewedAt, raw.fetchedAt).map((row) => {
+    return { ...row, ...badgeOf(row, mentioned) };
   });
+  return {
+    empty: null,
+    sections: [sectionOf(`Reviewed (n=${reviewing.length})`, reviewing, reviewedRowsOf, repo === null && grouped)]
+  };
 }
-function snoozedRows(group, now) {
+function buildMentionsView(raw, repo = null, grouped = false, snoozes2 = [], reads = emptyMentionReads(), now = Date.now()) {
+  if (raw.mentions === null) {
+    return {
+      empty: "Mention tracking is off. Turn on Track mentions in the settings (S) to list the PRs that mention you.",
+      sections: []
+    };
+  }
+  const { unread, snoozed, read } = splitMentions(inScopeOf(mentionItems(raw.mentions), repo), reads, snoozes2, now);
+  if (unread.length === 0 && snoozed.length === 0 && read.length === 0) {
+    return { empty: "No PR mentions you.", sections: [] };
+  }
+  const split = repo === null && grouped;
+  const unreadRowsOf = (group) => mentionRows(group, "unread", raw.fetchedAt);
+  const readRowsOf = (group) => mentionRows(group, "read", raw.fetchedAt);
+  const snoozedRowsOf = (group) => wakeRows(group, now).map((row, i) => {
+    return { ...row, mention: { mark: markOf(group[i]), state: "snoozed" } };
+  });
+  return {
+    empty: null,
+    sections: [
+      ...unread.length === 0 ? [] : [sectionOf(`Unread (n=${unread.length})`, unread, unreadRowsOf, split)],
+      ...snoozed.length === 0 ? [] : [sectionOf(`Snoozed (n=${snoozed.length})`, snoozed, snoozedRowsOf, split)],
+      ...read.length === 0 ? [] : [sectionOf(`Read (n=${read.length})`, read, readRowsOf, split)]
+    ]
+  };
+}
+function badgeOf(row, mentioned) {
+  return mentioned.has(row.ref) ? { mentioned: true } : {};
+}
+function wakeRows(group, now) {
+  return toPrRows(
+    group,
+    group.map((item) => `until ${formatWakeTime(item.until, now)}`)
+  );
+}
+function mentionRows(group, state, fetchedAt) {
   return toPrRows(
     group,
-    group.map((entry) => `until ${formatWakeTime(entry.until, now)}`)
+    group.map((item) => durationLead({ hours: durationHours(new Date(item.mentionedAt), fetchedAt) }))
   ).map((row, i) => {
-    return { ...row, pending: { requestedAt: group[i].requestedAt.getTime(), snoozed: true } };
+    return { ...row, mention: { mark: markOf(group[i]), state } };
   });
 }
 function buildOpenAuthoredView(raw, repo = null, grouped = false) {
@@ -1179,7 +1595,7 @@ function buildOpenAuthoredView(raw, repo = null, grouped = false) {
   if (open.length === 0) {
     return { empty: "No open authored PRs found.", sections: [] };
   }
-  const rowsOf2 = (group) => {
+  const rowsOf = (group) => {
     const ages = group.map((entry) => durationLead({ hours: durationHours(entry.pr.createdAt, raw.fetchedAt) }));
     const ageWidth = Math.max(...ages.map((age) => age.length));
     return toPrRows(
@@ -1191,14 +1607,14 @@ function buildOpenAuthoredView(raw, repo = null, grouped = false) {
   };
   const title = `Your open authored PRs (n=${open.length})`;
   if (repo === null && grouped) {
-    return { empty: null, sections: [{ title, rows: [], lists: groupedLists(open, rowsOf2) }] };
+    return { empty: null, sections: [{ title, rows: [], lists: groupedLists(open, rowsOf) }] };
   }
-  return { empty: null, sections: [{ title, rows: rowsOf2(open), lists: [] }] };
+  return { empty: null, sections: [{ title, rows: rowsOf(open), lists: [] }] };
 }
-function rowsOf(group) {
+function waitRows(group, startOf, fetchedAt) {
   return toPrRows(
     group,
-    group.map((entry) => durationLead(entry))
+    group.map((entry) => durationLead({ hours: durationHours(startOf(entry), fetchedAt) }))
   );
 }
 
@@ -1208,10 +1624,8 @@ function Footer({
   width,
   modal,
   editing,
-  tab,
-  authoredTab,
+  browse,
   views,
-  pendingCursor,
   copyLinks: copyLinks2,
   openError,
   successNotice,
@@ -1220,10 +1634,7 @@ function Footer({
   const notice = openError ?? successNotice ?? (stale ? "options changed \xB7 press r to reload" : "");
   const check = openError === null && successNotice !== null;
   const noticeWidth = notice === "" ? 0 : notice.length + (check ? 2 : 0) + 2;
-  const hints = truncated(
-    hintsFor(modal, editing, tab, authoredTab, views, pendingCursor, copyLinks2),
-    width - 2 - noticeWidth
-  );
+  const hints = truncated(hintsFor(modal, editing, browse, views, copyLinks2), width - 2 - noticeWidth);
   return /* @__PURE__ */ jsxs(Fragment, { children: [
     /* @__PURE__ */ jsx("box", { height: 1, children: /* @__PURE__ */ jsx("text", { wrapMode: "none", fg: theme.border, children: "\u2500".repeat(width) }) }),
     /* @__PURE__ */ jsxs(
@@ -1252,7 +1663,37 @@ function truncated(text, limit2) {
   }
   return limit2 <= 1 ? "" : `${text.slice(0, limit2 - 1).trimEnd()}\u2026`;
 }
-function hintsFor(modal, editing, tab, authoredTab, views, pendingCursor, copyLinks2) {
+function queueViewsOf(key, views) {
+  if (key === "pending") {
+    return { view: views.pending, repos: views.pendingRepos, scope: views.pendingScope };
+  }
+  if (key === "reviewed") {
+    return { view: views.reviewed, repos: views.reviewedRepos, scope: views.reviewedScope };
+  }
+  if (key === "mentions") {
+    return { view: views.mentions, repos: views.mentionsRepos, scope: views.mentionsScope };
+  }
+  return { view: views.open, repos: views.openRepos, scope: views.openScope };
+}
+function subTabHint(browse) {
+  if (browse.tab === 0) {
+    return `t ${cycledPendingSubTab(browse.pendingTab, 1).label.toLowerCase()} \xB7 `;
+  }
+  if (browse.tab === 1) {
+    return browse.authoredTab === "open" ? "t merged stats \xB7 " : "t open PRs \xB7 ";
+  }
+  return "";
+}
+function queueKeyHints(view, cursor) {
+  const row = queueRowAt(view, cursor);
+  const snoozeAction = snoozeActionOf(row);
+  const mentionAction = mentionActionOf(row);
+  const snooze = snoozeAction === null ? "" : `s ${snoozeAction} \xB7 `;
+  const mark = mentionAction === null ? "" : `d mark ${mentionAction} \xB7 `;
+  const markAll = unreadMentionRows(view).length > 0 ? "D read all \xB7 " : "";
+  return `${snooze}${mark}${markAll}`;
+}
+function hintsFor(modal, editing, browse, views, copyLinks2) {
   if (modal === "options") {
     return editing ? "enter apply \xB7 esc cancel" : "\u2191/\u2193 select \xB7 enter edit \xB7 \u2190/\u2192 toggle \xB7 s save \xB7 esc close \xB7 q quit";
   }
@@ -1265,20 +1706,20 @@ function hintsFor(modal, editing, tab, authoredTab, views, pendingCursor, copyLi
   if (modal === "snooze") {
     return "enter snooze \xB7 esc cancel";
   }
-  const toggle = tab === 1 ? authoredTab === "open" ? "t merged stats \xB7 " : "t open PRs \xB7 " : "";
-  if (tab === 0 || tab === 1 && authoredTab === "open") {
-    const scope2 = views === null ? null : tab === 0 ? views.pendingScope : views.openScope;
-    const repos2 = views === null ? [] : tab === 0 ? views.pendingRepos : views.openRepos;
+  const { tab } = browse;
+  const toggle = subTabHint(browse);
+  const queue = activeQueueTab(browse);
+  if (queue !== null) {
+    const { view: view2, repos: repos2, scope: scope2 } = views === null ? { view: null, repos: [], scope: null } : queueViewsOf(queue, views);
     if (scope2?.view === "list") {
       return `\u2191/\u2193 select \xB7 enter open \xB7 ${toggle}\u2190/\u2192 tabs \xB7 o options \xB7 S settings \xB7 r reload \xB7 R refetch \xB7 q quit`;
     }
-    const snoozeAction = tab === 0 && views !== null ? snoozeActionOf(queueRowAt(views.pending, pendingCursor)) : null;
-    const snooze = snoozeAction === null ? "" : `s ${snoozeAction} \xB7 `;
+    const queueKeys = queueKeyHints(view2, browse.rowCursors[queue]);
     const action = copyLinks2 ? "enter copy link" : "enter open";
     if (scope2 !== null && repos2.length > 0) {
-      return scope2.repo === null ? `\u2191/\u2193 select \xB7 ${action} \xB7 ${snooze}${toggle}g group by repo \xB7 esc back \xB7 o options \xB7 S settings \xB7 r reload \xB7 q quit` : `\u2191/\u2193 select \xB7 ${action} \xB7 ${snooze}${toggle}esc back \xB7 1-5 tabs \xB7 o options \xB7 S settings \xB7 r reload \xB7 R refetch \xB7 q quit`;
+      return scope2.repo === null ? `\u2191/\u2193 select \xB7 ${action} \xB7 ${queueKeys}${toggle}g group by repo \xB7 esc back \xB7 o options \xB7 S settings \xB7 r reload \xB7 q quit` : `\u2191/\u2193 select \xB7 ${action} \xB7 ${queueKeys}${toggle}esc back \xB7 1-5 tabs \xB7 o options \xB7 S settings \xB7 r reload \xB7 R refetch \xB7 q quit`;
     }
-    return `\u2191/\u2193 select \xB7 ${copyLinks2 ? "enter copy link" : "enter open in browser"} \xB7 ${snooze}${toggle}\u2190/\u2192 tabs \xB7 o options \xB7 S settings \xB7 r reload \xB7 R refetch \xB7 q quit`;
+    return `\u2191/\u2193 select \xB7 ${copyLinks2 ? "enter copy link" : "enter open in browser"} \xB7 ${queueKeys}${toggle}\u2190/\u2192 tabs \xB7 o options \xB7 S settings \xB7 r reload \xB7 R refetch \xB7 q quit`;
   }
   const scope = views === null ? null : tab === 1 ? views.mergedScope : tab === 2 ? views.reviewScope : tab === 3 ? views.sizeScope : views.commentScope;
   const repos = views === null ? [] : tab === 1 ? views.mergedRepos : tab === 2 ? views.reviewRepos : tab === 3 ? views.sizeRepos : views.commentRepos;
@@ -2536,7 +2977,8 @@ function QueuePanel({
   const renderRow = (row, index, indent) => {
     const isSelected = index === cursor;
     const bg = isSelected ? theme.selectedBg : void 0;
-    const fg = row.pending?.snoozed === true ? theme.muted : theme.text;
+    const parked = row.pending?.snoozed === true || row.mention?.state === "snoozed" || row.mention?.state === "read";
+    const fg = parked ? theme.muted : theme.text;
     const refStart = indent.length + 2 + row.lead.length + 2;
     return /* @__PURE__ */ jsxs5(
       "text",
@@ -2567,10 +3009,9 @@ function QueuePanel({
             "  "
           ] }),
           onRefClick === null ? /* @__PURE__ */ jsx6("a", { href: row.url, fg: theme.accent, bg, children: row.ref }) : /* @__PURE__ */ jsx6("span", { fg: theme.accent, bg, children: row.ref }),
-          /* @__PURE__ */ jsxs5("span", { fg, bg, children: [
-            "  ",
-            row.title
-          ] })
+          /* @__PURE__ */ jsx6("span", { fg, bg, children: "  " }),
+          row.mentioned === true && /* @__PURE__ */ jsx6("span", { fg: theme.accent, bg, children: "@ " }),
+          /* @__PURE__ */ jsx6("span", { fg, bg, children: row.title })
         ]
       },
       row.url
@@ -2647,91 +3088,6 @@ function RepoList({
   );
 }
 
-// src/tui/state/browse.ts
-var TABS = ["1 Awaiting you", "2 Your PRs", "3 Reviews", "4 PR size", "5 Comments"];
-var initialBrowseState = {
-  tab: 0,
-  authoredTab: "open",
-  scopes: {
-    pending: { view: "list" },
-    open: { view: "list" },
-    review: { view: "list" },
-    size: { view: "list" },
-    comment: { view: "list" },
-    merged: { view: "list" }
-  },
-  repoCursors: { pending: 0, open: 0, review: 0, size: 0, comment: 0, merged: 0 },
-  rowCursors: { pending: 0, open: 0 },
-  grouped: { pending: false, open: false },
-  expanded: { review: false, size: false, comment: false, merged: false }
-};
-function dropVanishedRepo(scope, repos) {
-  if (scope.view === "detail" && scope.repo !== null && !repos.some((option) => option.repo === scope.repo)) {
-    return { view: "list" };
-  }
-  return scope;
-}
-function cycled(previous, delta, count2) {
-  return (Math.min(previous, count2 - 1) + count2 + delta) % count2;
-}
-function browseReducer(state, action) {
-  switch (action.type) {
-    case "tabSelected": {
-      return { ...state, tab: action.tab };
-    }
-    case "tabCycled": {
-      return { ...state, tab: (state.tab + TABS.length + action.delta) % TABS.length };
-    }
-    case "subTabToggled": {
-      return { ...state, authoredTab: state.authoredTab === "open" ? "merged" : "open" };
-    }
-    case "repoCursorMoved": {
-      return {
-        ...state,
-        repoCursors: {
-          ...state.repoCursors,
-          [action.tab]: cycled(state.repoCursors[action.tab], action.delta, action.count)
-        }
-      };
-    }
-    case "rowCursorMoved": {
-      return {
-        ...state,
-        rowCursors: {
-          ...state.rowCursors,
-          [action.tab]: cycled(state.rowCursors[action.tab], action.delta, action.count)
-        }
-      };
-    }
-    case "repoOpened": {
-      return { ...state, scopes: { ...state.scopes, [action.tab]: { view: "detail", repo: action.repo } } };
-    }
-    case "pickerReturned": {
-      return { ...state, scopes: { ...state.scopes, [action.tab]: { view: "list" } } };
-    }
-    case "groupingToggled": {
-      return { ...state, grouped: { ...state.grouped, [action.tab]: !state.grouped[action.tab] } };
-    }
-    case "expandToggled": {
-      return { ...state, expanded: { ...state.expanded, [action.tab]: !state.expanded[action.tab] } };
-    }
-    case "dataLoaded": {
-      return {
-        ...state,
-        scopes: {
-          pending: dropVanishedRepo(state.scopes.pending, action.repos.pending),
-          open: dropVanishedRepo(state.scopes.open, action.repos.open),
-          review: dropVanishedRepo(state.scopes.review, action.repos.review),
-          size: dropVanishedRepo(state.scopes.size, action.repos.size),
-          comment: dropVanishedRepo(state.scopes.comment, action.repos.comment),
-          merged: dropVanishedRepo(state.scopes.merged, action.repos.merged)
-        }
-      };
-    }
-  }
-  return state;
-}
-
 // src/tui/components/TabBar.tsx
 import { jsx as jsx8, jsxs as jsxs7 } from "@opentui/react/jsx-runtime";
 function TabBar({ tab }) {
@@ -2746,23 +3102,22 @@ function TabBar({ tab }) {
     label
   )) });
 }
-var SUB_TABS = [
-  { key: "open", label: "Open" },
-  { key: "merged", label: "Merged & closed" }
-];
-function SubTabBar({ active }) {
+function SubTabBar({
+  tabs,
+  active,
+  alerts = {}
+}) {
   return /* @__PURE__ */ jsxs7("box", { flexDirection: "row", height: 1, paddingLeft: 1, marginBottom: 1, columnGap: 1, children: [
-    SUB_TABS.map(({ key, label }) => /* @__PURE__ */ jsx8(
-      "text",
-      {
-        wrapMode: "none",
-        fg: key === active ? theme.accent : theme.muted,
-        bg: key === active ? theme.selectedBg : void 0,
-        children: ` ${label} `
-      },
-      key
-    )),
-    /* @__PURE__ */ jsx8("text", { wrapMode: "none", fg: theme.dim, children: "t switches" })
+    tabs.map(({ key, label }) => {
+      const isActive = key === active;
+      const bg = isActive ? theme.selectedBg : void 0;
+      return /* @__PURE__ */ jsxs7("text", { wrapMode: "none", children: [
+        /* @__PURE__ */ jsx8("span", { fg: isActive ? theme.accent : theme.muted, bg, children: " " }),
+        alerts[key] === true && /* @__PURE__ */ jsx8("span", { fg: theme.accent, bg, children: "* " }),
+        /* @__PURE__ */ jsx8("span", { fg: isActive ? theme.accent : theme.muted, bg, children: `${label} ` })
+      ] }, key);
+    }),
+    /* @__PURE__ */ jsx8("text", { wrapMode: "none", fg: theme.dim, children: "t/T switches" })
   ] });
 }
 
@@ -2834,21 +3189,50 @@ function MainPanel({
   load,
   onRefClick
 }) {
-  return /* @__PURE__ */ jsx9("box", { flexGrow: 1, flexDirection: "column", marginTop: 1, children: views === null ? /* @__PURE__ */ jsx9(Placeholder, { error, loading, load }) : browse.tab === 0 ? /* @__PURE__ */ jsx9(
-    QueueTab,
-    {
-      prompt: "Select a repository and press enter to open its review queue.",
-      repos: views.pendingRepos,
-      scope: views.pendingScope,
-      view: views.pending,
-      repoCursor: browse.repoCursors.pending,
-      rowCursor: browse.rowCursors.pending,
-      grouped: browse.grouped.pending,
-      warning,
-      onRefClick
-    }
-  ) : browse.tab === 1 ? /* @__PURE__ */ jsxs8("box", { flexGrow: 1, flexDirection: "column", children: [
-    /* @__PURE__ */ jsx9(SubTabBar, { active: browse.authoredTab }),
+  return /* @__PURE__ */ jsx9("box", { flexGrow: 1, flexDirection: "column", marginTop: 1, children: views === null ? /* @__PURE__ */ jsx9(Placeholder, { error, loading, load }) : browse.tab === 0 ? /* @__PURE__ */ jsxs8("box", { flexGrow: 1, flexDirection: "column", children: [
+    /* @__PURE__ */ jsx9(SubTabBar, { tabs: PENDING_SUB_TABS, active: browse.pendingTab, alerts: views.alerts }),
+    browse.pendingTab === "pending" ? /* @__PURE__ */ jsx9(
+      QueueTab,
+      {
+        prompt: "Select a repository and press enter to open its review queue.",
+        repos: views.pendingRepos,
+        scope: views.pendingScope,
+        view: views.pending,
+        repoCursor: browse.repoCursors.pending,
+        rowCursor: browse.rowCursors.pending,
+        grouped: browse.grouped.pending,
+        warning,
+        onRefClick
+      }
+    ) : browse.pendingTab === "reviewed" ? /* @__PURE__ */ jsx9(
+      QueueTab,
+      {
+        prompt: "Select a repository and press enter to list the open PRs you reviewed.",
+        repos: views.reviewedRepos,
+        scope: views.reviewedScope,
+        view: views.reviewed,
+        repoCursor: browse.repoCursors.reviewed,
+        rowCursor: browse.rowCursors.reviewed,
+        grouped: browse.grouped.reviewed,
+        warning,
+        onRefClick
+      }
+    ) : /* @__PURE__ */ jsx9(
+      QueueTab,
+      {
+        prompt: "Select a repository and press enter to open its mention inbox.",
+        repos: views.mentionsRepos,
+        scope: views.mentionsScope,
+        view: views.mentions,
+        repoCursor: browse.repoCursors.mentions,
+        rowCursor: browse.rowCursors.mentions,
+        grouped: browse.grouped.mentions,
+        warning,
+        onRefClick
+      }
+    )
+  ] }) : browse.tab === 1 ? /* @__PURE__ */ jsxs8("box", { flexGrow: 1, flexDirection: "column", children: [
+    /* @__PURE__ */ jsx9(SubTabBar, { tabs: AUTHORED_SUB_TABS, active: browse.authoredTab }),
     browse.authoredTab === "open" ? /* @__PURE__ */ jsx9(
       QueueTab,
       {
@@ -3405,23 +3789,24 @@ import { useRenderer as useRenderer2 } from "@opentui/react";
 import { homedir as homedir2 } from "node:os";
 
 // src/tui/data/export.ts
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 
 // src/github.ts
 import { execFile } from "node:child_process";
 import { createHash } from "node:crypto";
 import { statSync } from "node:fs";
-import { join as join4, resolve } from "node:path";
+import { join as join5, resolve } from "node:path";
 import { promisify } from "node:util";
 var execFileAsync = promisify(execFile);
 var API_BASE = "https://api.github.com";
+var SEARCH_LIMIT = 1e3;
 var token;
 var ghBinary = "gh";
 function resolveDebugBinary(input) {
   const resolved = resolve(input);
   const stats = statSync(resolved, { throwIfNoEntry: false });
   if (stats?.isDirectory()) {
-    const binary = join4(resolved, "gh");
+    const binary = join5(resolved, "gh");
     if (!statSync(binary, { throwIfNoEntry: false })?.isFile()) {
       throw new CliError(`--debug directory "${input}" does not contain a gh executable`);
     }
@@ -3546,27 +3931,41 @@ async function resolveRepos(repos) {
   }
   return resolved;
 }
-async function searchPrsViaApi({ user, sinceIso, repos, includeDrafts, mode }) {
-  const qualifier = {
-    requested: "review-requested",
-    reviewed: "reviewed-by",
-    authored: "author"
-  }[mode];
-  const terms = ["type:pr", `${qualifier}:${user}`, `created:>=${sinceIso}`];
-  if (mode !== "authored") {
+function excludesOwnPrs(mode) {
+  return mode === "requested" || mode === "reviewed";
+}
+function isMentionQuery(query) {
+  return query === "mentioned" || query === "mentionedText";
+}
+function mentionTerm(user) {
+  return `"@${user}"`;
+}
+async function searchPrsViaApi({ user, sinceIso, repos, includeDrafts, query }) {
+  const terms = ["type:pr"];
+  if (query === "mentioned") {
+    terms.push(`mentions:${user}`, `updated:>=${sinceIso}`);
+  } else if (query === "mentionedText") {
+    terms.push(mentionTerm(user), `involves:${user}`, `updated:>=${sinceIso}`);
+  } else {
+    const qualifier = { requested: "review-requested", reviewed: "reviewed-by", authored: "author" }[query];
+    terms.push(`${qualifier}:${user}`, `created:>=${sinceIso}`);
+  }
+  const mode = isMentionQuery(query) ? "mentioned" : query;
+  if (excludesOwnPrs(mode)) {
     terms.push(`-author:${user}`);
   }
-  if (!includeDrafts) {
+  if (!includeDrafts && mode !== "mentioned") {
     terms.push("draft:false");
   }
   for (const repo of repos) {
     terms.push(`repo:${repo}`);
   }
-  const query = encodeURIComponent(terms.join(" "));
+  const encoded = encodeURIComponent(terms.join(" "));
+  const sort = mode === "mentioned" ? "&sort=updated&order=desc" : "";
   const items = [];
-  for (let page = 1; page <= 10; page++) {
+  for (let page = 1; page <= SEARCH_LIMIT / 100; page++) {
     const result = await api(
-      `/search/issues?q=${query}&per_page=100&page=${page}`
+      `/search/issues?q=${encoded}${sort}&per_page=100&page=${page}`
     );
     items.push(...result.items);
     if (result.items.length === 0 || items.length >= result.total_count) {
@@ -3580,39 +3979,60 @@ async function searchPrsViaApi({ user, sinceIso, repos, includeDrafts, mode }) {
       title: item.title,
       url: item.html_url,
       createdAt: item.created_at,
+      updatedAt: item.updated_at,
       isDraft: item.draft,
       state: item.state
     };
   });
 }
-async function searchPrs({ user, sinceIso, repos, includeDrafts, mode }) {
+async function searchPrs({ user, sinceIso, repos, includeDrafts, mode }) {
+  const queries = mode === "mentioned" ? ["mentioned", "mentionedText"] : [mode];
+  const results = await Promise.all(
+    queries.map((query) => {
+      return searchOnce({ user, sinceIso, repos, includeDrafts, query });
+    })
+  );
+  const capped = results.some((items) => items.length >= SEARCH_LIMIT);
+  if (results.length === 1) {
+    return { items: results[0], capped };
+  }
+  const byRef = /* @__PURE__ */ new Map();
+  for (const item of results.flat()) {
+    const ref = `${item.repository.nameWithOwner}#${item.number}`;
+    const known = byRef.get(ref);
+    if (known === void 0 || item.updatedAt > known.updatedAt) {
+      byRef.set(ref, item);
+    }
+  }
+  return { items: [...byRef.values()], capped };
+}
+async function searchOnce({ user, sinceIso, repos, includeDrafts, query }) {
   if (token) {
-    return searchPrsViaApi({ user, sinceIso, repos, includeDrafts, mode });
+    return searchPrsViaApi({ user, sinceIso, repos, includeDrafts, query });
   }
-  const modeFlag = {
-    requested: "--review-requested",
-    reviewed: "--reviewed-by",
-    authored: "--author"
-  }[mode];
+  const mode = isMentionQuery(query) ? "mentioned" : query;
+  const selection = query === "mentioned" ? ["--mentions", user, "--updated", `>=${sinceIso}`, "--sort", "updated", "--order", "desc"] : query === "mentionedText" ? [mentionTerm(user), "--involves", user, "--updated", `>=${sinceIso}`, "--sort", "updated", "--order", "desc"] : [
+    { requested: "--review-requested", reviewed: "--reviewed-by", authored: "--author" }[query],
+    user,
+    "--created",
+    `>=${sinceIso}`
+  ];
   const args = [
     "search",
     "prs",
-    modeFlag,
-    user,
-    "--created",
-    `>=${sinceIso}`,
+    ...selection,
     "--limit",
-    "1000",
+    String(SEARCH_LIMIT),
     "--json",
-    "number,repository,title,url,createdAt,isDraft,state"
+    "number,repository,title,url,createdAt,updatedAt,isDraft,state"
   ];
-  if (!includeDrafts) {
+  if (!includeDrafts && mode !== "mentioned") {
     args.push("--draft=false");
   }
   for (const repo of repos) {
     args.push("--repo", repo);
   }
-  if (mode !== "authored") {
+  if (excludesOwnPrs(mode)) {
     args.push("--", `-author:${user}`);
   }
   return JSON.parse(await gh(args));
@@ -3680,6 +4100,125 @@ async function fetchPrSizes(prs) {
   const data = await runGraphql(query);
   return prs.map((pr, i) => data[`pr${i}`]?.pullRequest ?? null);
 }
+var MENTION_TEXT_FRAGMENT = `
+  fragment MentionText on Comment {
+    id
+    body
+    createdAt
+    publishedAt
+    lastEditedAt
+    author { login }
+  }`;
+var PAGE_INFO = "pageInfo { hasNextPage endCursor }";
+var COMMENTS_PAGE = 100;
+var REVIEWS_PAGE = 50;
+var REVIEW_COMMENTS_PAGE = 20;
+function textPage(field, size, after) {
+  const cursor = after === void 0 ? "" : `, after: ${JSON.stringify(after)}`;
+  return `${field}(first: ${size}${cursor}) { ${PAGE_INFO} nodes { ...MentionText } }`;
+}
+function reviewsPage(after) {
+  const cursor = after === void 0 ? "" : `, after: ${JSON.stringify(after)}`;
+  return `reviews(first: ${REVIEWS_PAGE}${cursor}) {
+    ${PAGE_INFO}
+    nodes {
+      id
+      body
+      submittedAt
+      lastEditedAt
+      author { login }
+      ${textPage("comments", REVIEW_COMMENTS_PAGE)}
+    }
+  }`;
+}
+function pullRequestSelection(pr, selection) {
+  const [owner, name] = pr.repo.split("/");
+  return `repository(owner: ${JSON.stringify(owner)}, name: ${JSON.stringify(name)}) {
+    pullRequest(number: ${pr.number}) { ${selection} }
+  }`;
+}
+async function completeMentionPages(pr, raw) {
+  for (; ; ) {
+    const parts = [];
+    if (raw.comments.pageInfo.hasNextPage) {
+      const after = raw.comments.pageInfo.endCursor ?? void 0;
+      parts.push(`comments: ${pullRequestSelection(pr, textPage("comments", COMMENTS_PAGE, after))}`);
+    }
+    if (raw.reviews.pageInfo.hasNextPage) {
+      parts.push(`reviews: ${pullRequestSelection(pr, reviewsPage(raw.reviews.pageInfo.endCursor ?? void 0))}`);
+    }
+    const incompleteReviews = [];
+    for (const [i, review] of raw.reviews.nodes.entries()) {
+      if (review?.comments.pageInfo.hasNextPage) {
+        const after = review.comments.pageInfo.endCursor ?? void 0;
+        const page = textPage("comments", COMMENTS_PAGE, after);
+        incompleteReviews.push(i);
+        parts.push(`review${i}: node(id: ${JSON.stringify(review.id)}) { ... on PullRequestReview { ${page} } }`);
+      }
+    }
+    if (parts.length === 0) {
+      return true;
+    }
+    const query = `query {${parts.join("\n")}}
+${MENTION_TEXT_FRAGMENT}`;
+    const data = await runGraphql(query);
+    const pages = [];
+    if (raw.comments.pageInfo.hasNextPage) {
+      pages.push([raw.comments, data.comments?.pullRequest?.comments]);
+    }
+    if (raw.reviews.pageInfo.hasNextPage) {
+      pages.push([raw.reviews, data.reviews?.pullRequest?.reviews]);
+    }
+    for (const i of incompleteReviews) {
+      const review = raw.reviews.nodes[i];
+      if (review != null) {
+        pages.push([review.comments, data[`review${i}`]?.comments]);
+      }
+    }
+    if (pages.some(([, next]) => next === void 0)) {
+      return false;
+    }
+    for (const [list, next] of pages) {
+      appendPage(list, next);
+    }
+  }
+}
+function appendPage(list, next) {
+  if (next !== void 0) {
+    list.nodes.push(...next.nodes);
+    list.pageInfo = next.pageInfo;
+  }
+}
+function present(nodes) {
+  return nodes.filter((node) => node !== null);
+}
+async function fetchPrMentionDetails(prs) {
+  const parts = prs.map((pr, i) => {
+    const selection = `...MentionText ${textPage("comments", COMMENTS_PAGE)} ${reviewsPage()}`;
+    return `pr${i}: ${pullRequestSelection(pr, selection)}`;
+  });
+  const query = `query {${parts.join("\n")}}
+${MENTION_TEXT_FRAGMENT}`;
+  const data = await runGraphql(query);
+  const raws = prs.map((pr, i) => data[`pr${i}`]?.pullRequest ?? null);
+  for (const [i, raw] of raws.entries()) {
+    if (raw !== null && !await completeMentionPages(prs[i], raw)) {
+      raws[i] = null;
+    }
+  }
+  return raws.map((raw) => {
+    if (raw === null) {
+      return null;
+    }
+    return {
+      ...raw,
+      comments: present(raw.comments.nodes),
+      reviews: present(raw.reviews.nodes).map((review) => {
+        return { ...review, comments: present(review.comments.nodes) };
+      })
+    };
+  });
+}
 
 // src/data.ts
 var BATCH_SIZE = 25;
@@ -3706,7 +4245,7 @@ function createLimiter(maxConcurrent) {
   };
 }
 var limit = createLimiter(MAX_CONCURRENT_BATCHES);
-async function fetchMissing(misses, fetchBatch, found, cache, onBatchDone) {
+async function fetchMissing(misses, fetchBatch, found, cache, onBatchDone, cacheable = (pr) => pr.state !== "open") {
   const batches = [];
   for (let offset = 0; offset < misses.length; offset += BATCH_SIZE) {
     batches.push(misses.slice(offset, offset + BATCH_SIZE));
@@ -3720,7 +4259,7 @@ async function fetchMissing(misses, fetchBatch, found, cache, onBatchDone) {
           const details = detailsList[i];
           const key = prKey(pr.repo, pr.number);
           found.set(key, details);
-          if (details !== null && pr.state !== "open") {
+          if (details !== null && cacheable(pr)) {
             cache.set(key, details);
           }
         }
@@ -3888,12 +4427,153 @@ async function fetchSizeRaw(prs, onProgress, options = {}) {
   }
   return { sizes, cacheHits };
 }
+function collectMentionedPrs(mentioned) {
+  return mentioned.map((item) => {
+    return {
+      repo: item.repository.nameWithOwner,
+      number: item.number,
+      title: item.title,
+      url: item.url,
+      state: item.state,
+      createdAt: new Date(item.createdAt),
+      updatedAt: new Date(item.updatedAt)
+    };
+  });
+}
+function mentionPattern(user) {
+  const escaped = user.replaceAll(/[$()*+.?[\\\]^{|}]/g, String.raw`\$&`);
+  return new RegExp(String.raw`(?<![\w/-])@${escaped}(?![\w-])`, "i");
+}
+function latestOf(...times) {
+  let latest = Number.NEGATIVE_INFINITY;
+  for (const time of times) {
+    if (time !== null) {
+      latest = Math.max(latest, new Date(time).getTime());
+    }
+  }
+  return new Date(latest);
+}
+function findMentions(details, user) {
+  const pattern = mentionPattern(user);
+  const own = user.toLowerCase();
+  const sources = [];
+  const addText = (text, floor = null) => {
+    sources.push({
+      id: text.id,
+      body: text.body,
+      at: latestOf(text.publishedAt ?? text.createdAt, text.lastEditedAt, floor),
+      login: text.author?.login ?? null
+    });
+  };
+  addText(details);
+  for (const comment of details.comments) {
+    addText(comment);
+  }
+  for (const review of details.reviews) {
+    if (review.submittedAt === null) {
+      continue;
+    }
+    sources.push({
+      id: review.id,
+      body: review.body,
+      at: latestOf(review.submittedAt, review.lastEditedAt),
+      login: review.author?.login ?? null
+    });
+    for (const comment of review.comments) {
+      addText(comment, review.submittedAt);
+    }
+  }
+  const mentions = [];
+  for (const source of sources) {
+    if (source.login?.toLowerCase() !== own && pattern.test(source.body)) {
+      mentions.push({ id: source.id, at: source.at });
+    }
+  }
+  return mentions;
+}
+async function fetchMentionsRaw(prs, user, onProgress, options = {}) {
+  const cache = new PrCache("mentions");
+  const found = /* @__PURE__ */ new Map();
+  const misses = [];
+  const login = user.toLowerCase();
+  for (const pr of prs) {
+    const key = prKey(pr.repo, pr.number);
+    const cached = options.bypassCache === true ? void 0 : cache.get(key);
+    if (cached?.user === login && cached.updatedAt === pr.updatedAt.toISOString()) {
+      found.set(key, cached);
+    } else {
+      misses.push(pr);
+    }
+  }
+  const cacheHits = prs.length - misses.length;
+  onProgress?.(cacheHits, prs.length);
+  const fetchBatch = async (batch) => {
+    const detailsList = await fetchPrMentionDetails(batch);
+    return batch.map((pr, i) => {
+      const details = detailsList[i];
+      if (details === null) {
+        return null;
+      }
+      return {
+        user: login,
+        updatedAt: pr.updatedAt.toISOString(),
+        mentions: findMentions(details, user).map(({ id, at }) => {
+          return { id, at: at.toISOString() };
+        })
+      };
+    });
+  };
+  await fetchMissing(
+    misses,
+    fetchBatch,
+    found,
+    cache,
+    (completed) => {
+      onProgress?.(cacheHits + completed, prs.length);
+    },
+    () => true
+  );
+  cache.save();
+  const mentions = [];
+  const since = options.since?.getTime() ?? Number.NEGATIVE_INFINITY;
+  for (const pr of prs) {
+    const entry = found.get(prKey(pr.repo, pr.number));
+    if (entry == null) {
+      mentions.push({ pr, mentions: null, earlier: [] });
+      continue;
+    }
+    const inWindow = [];
+    const earlier = [];
+    for (const { id, at } of entry.mentions) {
+      const time = new Date(at);
+      if (time.getTime() >= since) {
+        inWindow.push({ id, at: time });
+      } else {
+        earlier.push(id);
+      }
+    }
+    if (inWindow.length > 0) {
+      mentions.push({ pr, mentions: inWindow, earlier });
+    }
+  }
+  return { mentions, cacheHits };
+}
 
 // src/tui/data/load.ts
 function reviveRawData(data) {
+  const mentions = data.mentions ?? null;
   return {
     ...data,
     fetchedAt: new Date(data.fetchedAt),
+    mentions: mentions === null ? null : mentions.map((entry) => {
+      return {
+        pr: { ...entry.pr, createdAt: new Date(entry.pr.createdAt), updatedAt: new Date(entry.pr.updatedAt) },
+        mentions: entry.mentions === null ? null : entry.mentions.map((mention) => {
+          return { id: mention.id, at: new Date(mention.at) };
+        }),
+        earlier: entry.earlier ?? []
+      };
+    }),
     reviewResults: data.reviewResults.map((result) => {
       const pr = { ...result.pr, createdAt: new Date(result.pr.createdAt) };
       if (result.kind === "pending") {
@@ -3920,6 +4600,19 @@ function reviveRawData(data) {
     })
   };
 }
+function cutMentions(entries, cutoff) {
+  return entries.flatMap((entry) => {
+    if (entry.mentions === null) {
+      return entry.pr.updatedAt >= cutoff ? [entry] : [];
+    }
+    const mentions = entry.mentions.filter((mention) => mention.at >= cutoff);
+    if (mentions.length === 0) {
+      return [];
+    }
+    const cut = entry.mentions.filter((mention) => mention.at < cutoff).map((mention) => mention.id);
+    return [{ ...entry, mentions, earlier: [...entry.earlier, ...cut] }];
+  });
+}
 function loadSnapshot(options) {
   const stored = readCacheFile("snapshot");
   if (stored?.params === void 0) {
@@ -3952,11 +4645,13 @@ function loadSnapshot(options) {
   const cutoff = new Date(sinceIso);
   const reviewResults = data.reviewResults.filter((result) => result.pr.createdAt >= cutoff);
   const sizes = data.sizes.filter((entry) => entry.pr.createdAt >= cutoff);
+  const mentions = data.mentions === null ? null : cutMentions(data.mentions, cutoff);
   return {
     ...data,
     sinceIso,
     reviewResults,
     sizes,
+    mentions,
     /**
      * The creation dates of inaccessible authored PRs are unknown, so the
      * inaccessible count carries over unchanged.
@@ -3974,27 +4669,30 @@ function saveSnapshot(options, data) {
   };
   writeCacheFile("snapshot", { params, data });
 }
-async function loadData(options, onPhase, { bypassCache = false } = {}) {
+async function loadData(options, onPhase, { bypassCache = false, mentions = false } = {}) {
   const sinceIso = parseSince(options.since).toISOString().slice(0, 10);
   onPhase({ phase: "search" });
   const repoNames = options.repos.split(",").map((name) => name.trim()).filter((name) => name !== "");
   const [user, repos] = await Promise.all([resolveUser(options.user, bypassCache), resolveRepos(repoNames)]);
   const includeDrafts = options.includeDrafts;
-  const [requested, reviewed, authored] = await Promise.all([
+  const [requested, reviewed, authored, mentioned] = await Promise.all([
     searchPrs({ user, sinceIso, repos, includeDrafts, mode: "requested" }),
     searchPrs({ user, sinceIso, repos, includeDrafts, mode: "reviewed" }),
-    searchPrs({ user, sinceIso, repos, includeDrafts, mode: "authored" })
+    searchPrs({ user, sinceIso, repos, includeDrafts, mode: "authored" }),
+    mentions ? searchPrs({ user, sinceIso, repos, includeDrafts, mode: "mentioned" }) : null
   ]);
-  const reviewPrs = collectReviewPrs(requested, reviewed);
-  const authoredPrs = collectAuthoredPrs(authored);
-  const progress = { review: 0, sizes: 0 };
-  const total = reviewPrs.length + authoredPrs.length;
+  const reviewPrs = collectReviewPrs(requested.items, reviewed.items);
+  const authoredPrs = collectAuthoredPrs(authored.items);
+  const mentionedPrs = mentioned === null ? null : collectMentionedPrs(mentioned.items);
+  const searchCapped = [requested, reviewed, authored, mentioned].some((result) => result?.capped === true);
+  const progress = { review: 0, sizes: 0, mentions: 0 };
+  const total = reviewPrs.length + authoredPrs.length + (mentionedPrs?.length ?? 0);
   const report = () => {
-    onPhase({ phase: "details", done: progress.review + progress.sizes, total });
+    onPhase({ phase: "details", done: progress.review + progress.sizes + progress.mentions, total });
   };
   report();
   const countedStates = options.reviewTypes === "" ? void 0 : parseReviewTypes(options.reviewTypes);
-  const [review, size] = await Promise.all([
+  const [review, size, mention] = await Promise.all([
     reviewPrs.length === 0 ? { results: [], cacheHits: 0 } : fetchReviewRaw(
       reviewPrs,
       user,
@@ -4011,6 +4709,18 @@ async function loadData(options, onPhase, { bypassCache = false } = {}) {
         report();
       },
       { bypassCache }
+    ),
+    mentionedPrs === null || mentionedPrs.length === 0 ? { mentions: [], cacheHits: 0 } : fetchMentionsRaw(
+      mentionedPrs,
+      user,
+      (done) => {
+        progress.mentions = done;
+        report();
+      },
+      {
+        bypassCache,
+        since: new Date(sinceIso)
+      }
     )
   ]);
   const data = {
@@ -4020,7 +4730,8 @@ async function loadData(options, onPhase, { bypassCache = false } = {}) {
     reviewResults: review.results,
     sizes: size.sizes,
     authoredTotal: authoredPrs.length,
-    searchCapped: requested.length >= 1e3 || reviewed.length >= 1e3 || authored.length >= 1e3,
+    mentions: mentionedPrs === null ? null : mention.mentions,
+    searchCapped,
     fetchedAt: /* @__PURE__ */ new Date()
   };
   saveSnapshot(options, data);
@@ -4203,7 +4914,7 @@ function buildStatsReport(raw, options) {
   };
 }
 function exportFile() {
-  return join5(process.cwd(), "pr-stats.json");
+  return join6(process.cwd(), "pr-stats.json");
 }
 function exportStatsFile(raw, options) {
   writeFileAtomic(exportFile(), `${JSON.stringify(buildStatsReport(raw, options), null, 2)}
@@ -4273,6 +4984,12 @@ var SETTINGS = [
     label: "Desktop notifications",
     hint: "notifies you when a load finds a PR newly awaiting your review or a review re-requested from you"
   },
+  {
+    key: "notifyMentions",
+    section: "Notifications",
+    label: "Mention notifications",
+    hint: "also notifies you when someone @-mentions you on a PR, your own PRs included \xB7 needs desktop notifications and mention tracking on"
+  },
   {
     key: "notifyChannel",
     section: "Notifications",
@@ -4291,9 +5008,15 @@ var SETTINGS = [
     label: "Copy instead of open",
     hint: "enter and a click on a PR reference copy its link to the clipboard instead of opening the browser"
   },
+  {
+    key: "trackMentions",
+    section: "Awaiting you",
+    label: "Track mentions",
+    hint: "searches the PRs that @-mention you on every load and lists the unread ones in the Mentions inbox \xB7 off skips the search"
+  },
   {
     key: "snoozeDuration",
-    section: "Snooze",
+    section: "Awaiting you",
     label: "Default snooze",
     hint: "the duration the snooze dialog starts with when s snoozes a PR, like 30m, 2h, or 1d \xB7 enter edits the value"
   },
@@ -4556,6 +5279,8 @@ function SettingsModal({
   autoReload: autoReload2,
   reloadInterval: reloadInterval2,
   notifications: notifications2,
+  trackMentions: trackMentions2,
+  notifyMentions: notifyMentions2,
   notifyChannel: notifyChannel2,
   copyLinks: copyLinks2,
   snoozeDuration: snoozeDuration2,
@@ -4585,6 +5310,8 @@ function SettingsModal({
             autoReload: autoReload2,
             reloadInterval: reloadInterval2,
             notifications: notifications2,
+            trackMentions: trackMentions2,
+            notifyMentions: notifyMentions2,
             channelValue,
             deliveryValue,
             copyLinks: copyLinks2,
@@ -4608,6 +5335,8 @@ function SettingValue({
   autoReload: autoReload2,
   reloadInterval: reloadInterval2,
   notifications: notifications2,
+  trackMentions: trackMentions2,
+  notifyMentions: notifyMentions2,
   channelValue,
   deliveryValue,
   copyLinks: copyLinks2,
@@ -4635,6 +5364,16 @@ function SettingValue({
     case "notifications": {
       return /* @__PURE__ */ jsx12(ToggleValue, { value: notifications2 ? "yes" : "no", isSelected });
     }
+    case "notifyMentions": {
+      return /* @__PURE__ */ jsx12(
+        ToggleValue,
+        {
+          value: notifyMentions2 ? "yes" : "no",
+          isSelected,
+          active: notifications2 && trackMentions2
+        }
+      );
+    }
     case "notifyChannel": {
       return /* @__PURE__ */ jsx12(ToggleValue, { value: channelValue, isSelected });
     }
@@ -4644,6 +5383,9 @@ function SettingValue({
     case "copyLinks": {
       return /* @__PURE__ */ jsx12(ToggleValue, { value: copyLinks2 ? "yes" : "no", isSelected });
     }
+    case "trackMentions": {
+      return /* @__PURE__ */ jsx12(ToggleValue, { value: trackMentions2 ? "yes" : "no", isSelected });
+    }
     case "snoozeDuration": {
       if (isEditing) {
         return /* @__PURE__ */ jsx12(ModalInput, { width: 16, value: snoozeDuration2, onDraft, onSubmit });
@@ -4667,15 +5409,15 @@ function SettingValue({
     }
   }
 }
-function ToggleValue({ value: value2, isSelected }) {
+function ToggleValue({ value: value2, isSelected, active = true }) {
   if (isSelected) {
     return /* @__PURE__ */ jsxs11("text", { wrapMode: "none", children: [
       /* @__PURE__ */ jsx12("span", { fg: theme.muted, children: "\u2039 " }),
-      /* @__PURE__ */ jsx12("b", { fg: theme.text, children: value2 }),
+      /* @__PURE__ */ jsx12("b", { fg: active ? theme.text : theme.muted, children: value2 }),
       /* @__PURE__ */ jsx12("span", { fg: theme.muted, children: " \u203A" })
     ] });
   }
-  return /* @__PURE__ */ jsx12("text", { wrapMode: "none", fg: theme.muted, children: value2 });
+  return /* @__PURE__ */ jsx12("text", { wrapMode: "none", fg: active ? theme.muted : theme.dim, children: value2 });
 }
 function IntervalValue({ value: value2, active, isSelected }) {
   if (!active) {
@@ -4789,6 +5531,8 @@ function Modals({
   autoReload: autoReload2,
   reloadInterval: reloadInterval2,
   notifications: notifications2,
+  trackMentions: trackMentions2,
+  notifyMentions: notifyMentions2,
   notifyChannel: notifyChannel2,
   copyLinks: copyLinks2,
   snoozeDuration: snoozeDuration2,
@@ -4829,6 +5573,8 @@ function Modals({
         autoReload: autoReload2,
         reloadInterval: reloadInterval2,
         notifications: notifications2,
+        trackMentions: trackMentions2,
+        notifyMentions: notifyMentions2,
         notifyChannel: notifyChannel2,
         copyLinks: copyLinks2,
         snoozeDuration: snoozeDuration2,
@@ -4896,6 +5642,54 @@ function diffReviewRequests(previous, results) {
   }
   return { baseline, newRequests, reRequests };
 }
+var OBSERVATION_MARGIN_MS = 10 * 60 * 1e3;
+function diffMentions(previous, entries, observedAt) {
+  const seen = new Set(previous?.seen);
+  const unread = new Map(previous?.unread);
+  const newMentions = [];
+  for (const entry of entries) {
+    const key = `${entry.pr.repo}#${entry.pr.number}`;
+    const cutoff = previous === null ? observedAt.getTime() : previous.unread.get(key) ?? previous.observedAt;
+    if (entry.mentions === null) {
+      unread.set(key, cutoff);
+      continue;
+    }
+    unread.delete(key);
+    let isNew = false;
+    for (const mention of entry.mentions) {
+      if (previous !== null && !previous.seen.has(mention.id) && mention.at.getTime() > cutoff - OBSERVATION_MARGIN_MS) {
+        isNew = true;
+      }
+      seen.add(mention.id);
+    }
+    for (const id of entry.earlier) {
+      seen.add(id);
+    }
+    if (isNew) {
+      newMentions.push(entry.pr);
+    }
+  }
+  return { baseline: { seen, observedAt: observedAt.getTime(), unread }, newMentions };
+}
+function saveMentionBaseline(key, baseline) {
+  if (baseline === null) {
+    return writeCacheFile("mention-baseline", null);
+  }
+  const stored = {
+    key,
+    seen: [...baseline.seen],
+    observedAt: baseline.observedAt,
+    unread: [...baseline.unread]
+  };
+  return writeCacheFile("mention-baseline", stored);
+}
+function loadMentionBaseline(key) {
+  const stored = readCacheFile("mention-baseline");
+  if (stored === null || stored.key !== key) {
+    return null;
+  }
+  return { seen: new Set(stored.seen), observedAt: stored.observedAt, unread: new Map(stored.unread) };
+}
 var MAX_LISTED = 3;
 var TEST_NOTIFICATION = {
   title: "pr-stats",
@@ -4917,6 +5711,12 @@ function describeSnoozeWakeUps(prs) {
   }
   return [describe(prs, "Snooze ended on", "snoozed PRs are back in your queue")];
 }
+function describeMentions(changes) {
+  if (changes.newMentions.length === 0) {
+    return [];
+  }
+  return [describe(changes.newMentions, "Mentioned on", "PRs mention you")];
+}
 function describe(prs, singleTitle, pluralTitle) {
   if (prs.length === 1) {
     const [pr] = prs;
@@ -4982,7 +5782,7 @@ function useDeferredLoading(isLoading, { showDelay = 300, minDuration = 500 } =
 
 // src/tui/hooks/useLoader.ts
 import { useEffect as useEffect6, useRef as useRef4, useState as useState3 } from "react";
-function useLoader(options, noCache2, callbacks = {}) {
+function useLoader(options, { noCache: noCache2, mentions }, callbacks = {}) {
   const { onSnapshot, onLoaded } = callbacks;
   const [startupSnapshot] = useState3(() => noCache2 ? null : loadSnapshot(options));
   const [raw, setRaw] = useState3(startupSnapshot);
@@ -5003,7 +5803,7 @@ function useLoader(options, noCache2, callbacks = {}) {
       }
     };
     try {
-      const data = await loadData(options, publishPhase, { bypassCache });
+      const data = await loadData(options, publishPhase, { bypassCache, mentions });
       if (disposedRef.current) {
         return;
       }
@@ -5056,10 +5856,86 @@ function useLoader(options, noCache2, callbacks = {}) {
   };
 }
 
-// src/tui/hooks/useReviewNotifications.ts
+// src/tui/hooks/useMentionNotifications.ts
 import { useRef as useRef5 } from "react";
-function useReviewNotifications(enabled2, notify, onError) {
+function useMentionNotifications(enabled2, notify, onError, restore) {
   const baselineRef = useRef5(null);
+  const restoredRef = useRef5(!restore);
+  return (key, mentions, observedAt) => {
+    if (!restoredRef.current) {
+      restoredRef.current = true;
+      const restored = loadMentionBaseline(key);
+      if (restored !== null) {
+        baselineRef.current = { key, baseline: restored };
+      }
+    }
+    if (mentions === null) {
+      baselineRef.current = null;
+      saveMentionBaseline(key, null);
+      return;
+    }
+    const previous = baselineRef.current?.key === key ? baselineRef.current.baseline : null;
+    const changes = diffMentions(previous, mentions, observedAt);
+    baselineRef.current = { key, baseline: changes.baseline };
+    saveMentionBaseline(key, changes.baseline);
+    if (!enabled2) {
+      return;
+    }
+    for (const notification of describeMentions(changes)) {
+      notify(notification.title, notification.body, onError);
+    }
+  };
+}
+
+// src/tui/hooks/useMentionReads.ts
+import { useRef as useRef6, useState as useState4 } from "react";
+var NO_READS = emptyMentionReads();
+function useMentionReads(initial2) {
+  const [state, setState] = useState4({ all: initial2, user: null });
+  const latest = useRef6(state);
+  const commit = (user, apply) => {
+    const { all } = latest.current;
+    const reads = all.get(user) ?? NO_READS;
+    const next = apply(reads);
+    const changed = next !== reads;
+    if (!changed && user === latest.current.user) {
+      return true;
+    }
+    latest.current = { all: changed ? new Map(all).set(user, next) : all, user };
+    setState(latest.current);
+    return changed ? writeMentionReads(latest.current.all) : true;
+  };
+  const change = (apply) => {
+    const { user } = latest.current;
+    return user === null ? true : commit(user, apply);
+  };
+  return {
+    reads: state.user === null ? NO_READS : state.all.get(state.user) ?? NO_READS,
+    observe: (data) => {
+      commit(
+        data.user.toLowerCase(),
+        (reads) => data.mentions === null ? unseedMentionReads(reads) : seedMentionReads(reads, {
+          at: data.fetchedAt.getTime(),
+          ids: data.mentions.flatMap(mentionIdsOf)
+        })
+      );
+    },
+    markRead: (ref, mark) => change((reads) => markMentionRead(reads, ref, mark)),
+    markAllRead: (marks) => change((reads) => {
+      let next = reads;
+      for (const { ref, mark } of marks) {
+        next = markMentionRead(next, ref, mark);
+      }
+      return next;
+    }),
+    markUnread: (ref) => change((reads) => markMentionUnread(reads, ref))
+  };
+}
+
+// src/tui/hooks/useReviewNotifications.ts
+import { useRef as useRef7 } from "react";
+function useReviewNotifications(enabled2, notify, onError) {
+  const baselineRef = useRef7(null);
   return (key, results) => {
     const previous = baselineRef.current?.key === key ? baselineRef.current.baseline : null;
     const changes = diffReviewRequests(previous, results);
@@ -5074,17 +5950,17 @@ function useReviewNotifications(enabled2, notify, onError) {
 }
 
 // src/tui/hooks/useSnoozes.ts
-import { useState as useState4 } from "react";
+import { useState as useState5 } from "react";
 function useSnoozes(initial2) {
-  const [snoozes2, setSnoozes] = useState4(initial2);
+  const [snoozes2, setSnoozes] = useState5(initial2);
   const commit = (next) => {
     setSnoozes(next);
     return writeSnoozes(next);
   };
   return {
     snoozes: snoozes2,
-    add: (snooze) => commit([...snoozes2.filter((entry) => entry.ref !== snooze.ref), snooze]),
-    remove: (refs) => commit(snoozes2.filter((entry) => !refs.includes(entry.ref)))
+    add: (snooze) => commit([...snoozes2.filter((entry) => !snoozeMatches(entry, snooze)), snooze]),
+    remove: (targets) => commit(snoozes2.filter((entry) => !targets.some((target) => snoozeMatches(entry, target))))
   };
 }
 
@@ -5175,49 +6051,110 @@ function buildSizeRepoOptions(raw) {
     })
   ];
 }
-function pendingDetail(counts) {
-  const awaiting = `${counts.awaiting} ${counts.awaiting === 1 ? "PR" : "PRs"} awaiting your review`;
-  return awaiting + (counts.snoozed > 0 ? `, ${counts.snoozed} snoozed` : "") + (counts.reviewing > 0 ? `, ${counts.reviewing} reviewed` : "");
+function pickerOf(countsByRepo, zero, order, detail) {
+  if (countsByRepo.size < 2) {
+    return [];
+  }
+  const entries = [...countsByRepo.entries()].toSorted((a, b) => order(a[1], b[1]) || a[0].localeCompare(b[0]));
+  const totals = zero();
+  for (const [, counts] of entries) {
+    for (const [key, count2] of Object.entries(counts)) {
+      totals[key] += count2;
+    }
+  }
+  return [
+    { repo: null, label: "All repos", detail: detail(totals) },
+    ...entries.map(([repo, counts]) => {
+      return { repo, label: repo, detail: detail(counts) };
+    })
+  ];
 }
-function buildPendingRepoOptions(raw, snoozes2 = [], now = Date.now()) {
+function bump(countsByRepo, repo, key) {
+  const counts = countsByRepo.get(repo);
+  if (counts !== void 0) {
+    counts[key] += 1;
+  }
+}
+function reviewRepos(raw, zero) {
   const countsByRepo = /* @__PURE__ */ new Map();
-  const countsOf = (repo) => {
-    const counts = countsByRepo.get(repo) ?? { awaiting: 0, snoozed: 0, reviewing: 0 };
-    countsByRepo.set(repo, counts);
-    return counts;
-  };
   for (const result of raw.reviewResults) {
-    countsOf(result.pr.repo);
+    if (!countsByRepo.has(result.pr.repo)) {
+      countsByRepo.set(result.pr.repo, zero());
+    }
   }
+  return countsByRepo;
+}
+function zeroPending() {
+  return { awaiting: 0, snoozed: 0 };
+}
+function pendingDetail(counts) {
+  const awaiting = `${counts.awaiting} ${counts.awaiting === 1 ? "PR" : "PRs"} awaiting your review`;
+  return awaiting + (counts.snoozed > 0 ? `, ${counts.snoozed} snoozed` : "");
+}
+function buildPendingRepoOptions(raw, snoozes2 = [], now = Date.now()) {
+  const countsByRepo = reviewRepos(raw, zeroPending);
   if (countsByRepo.size < 2) {
     return [];
   }
-  const stats = computeReviewStats(raw.reviewResults, { now: raw.fetchedAt });
-  const { awaiting, snoozed } = splitSnoozed(stats.pending, snoozes2, now);
+  const { awaiting, snoozed } = splitSnoozed(pendingRequests(raw.reviewResults), snoozes2, now);
   for (const entry of awaiting) {
-    countsOf(entry.pr.repo).awaiting += 1;
+    bump(countsByRepo, entry.pr.repo, "awaiting");
   }
   for (const entry of snoozed) {
-    countsOf(entry.pr.repo).snoozed += 1;
+    bump(countsByRepo, entry.pr.repo, "snoozed");
   }
-  for (const entry of stats.reviewing) {
-    countsOf(entry.pr.repo).reviewing += 1;
+  return pickerOf(countsByRepo, zeroPending, (a, b) => b.awaiting - a.awaiting || b.snoozed - a.snoozed, pendingDetail);
+}
+function zeroReviewed() {
+  return { reviewed: 0 };
+}
+function reviewedDetail(counts) {
+  return `${counts.reviewed} reviewed ${counts.reviewed === 1 ? "PR" : "PRs"} still open`;
+}
+function buildReviewedRepoOptions(raw) {
+  const countsByRepo = reviewRepos(raw, zeroReviewed);
+  if (countsByRepo.size < 2) {
+    return [];
   }
-  const entries = [...countsByRepo.entries()].toSorted(
-    (a, b) => b[1].awaiting - a[1].awaiting || b[1].snoozed - a[1].snoozed || b[1].reviewing - a[1].reviewing || a[0].localeCompare(b[0])
-  );
-  const totals = { awaiting: 0, snoozed: 0, reviewing: 0 };
-  for (const [, counts] of entries) {
-    totals.awaiting += counts.awaiting;
-    totals.snoozed += counts.snoozed;
-    totals.reviewing += counts.reviewing;
+  for (const entry of latestReviews(raw.reviewResults)) {
+    bump(countsByRepo, entry.pr.repo, "reviewed");
   }
-  return [
-    { repo: null, label: "All repos", detail: pendingDetail(totals) },
-    ...entries.map(([repo, counts]) => {
-      return { repo, label: repo, detail: pendingDetail(counts) };
-    })
-  ];
+  return pickerOf(countsByRepo, zeroReviewed, (a, b) => b.reviewed - a.reviewed, reviewedDetail);
+}
+function zeroMentions() {
+  return { unread: 0, snoozed: 0, read: 0 };
+}
+function mentionDetail(counts) {
+  const unread = `${counts.unread} unread ${counts.unread === 1 ? "mention" : "mentions"}`;
+  return unread + (counts.snoozed > 0 ? `, ${counts.snoozed} snoozed` : "") + (counts.read > 0 ? `, ${counts.read} read` : "");
+}
+function buildMentionRepoOptions(raw, snoozes2 = [], reads = emptyMentionReads(), now = Date.now()) {
+  const countsByRepo = /* @__PURE__ */ new Map();
+  const items = mentionItems(raw.mentions ?? []);
+  for (const item of items) {
+    if (!countsByRepo.has(item.pr.repo)) {
+      countsByRepo.set(item.pr.repo, zeroMentions());
+    }
+  }
+  if (countsByRepo.size < 2) {
+    return [];
+  }
+  const { unread, snoozed, read } = splitMentions(items, reads, snoozes2, now);
+  for (const [state, group] of [
+    ["unread", unread],
+    ["snoozed", snoozed],
+    ["read", read]
+  ]) {
+    for (const item of group) {
+      bump(countsByRepo, item.pr.repo, state);
+    }
+  }
+  return pickerOf(
+    countsByRepo,
+    zeroMentions,
+    (a, b) => b.unread - a.unread || b.snoozed - a.snoozed || b.read - a.read,
+    mentionDetail
+  );
 }
 function openDetail(count2) {
   return `${count2} open ${count2 === 1 ? "PR" : "PRs"}`;
@@ -6641,7 +7578,7 @@ function resolveScope(scope, repos) {
   }
   return dropVanishedRepo(scope, repos);
 }
-function useViewModel(raw, options, width, scopes, grouping, expanded, snoozes2, themeEpoch) {
+function useViewModel(raw, options, width, scopes, grouping, expanded, snoozes2, reads, themeEpoch) {
   return useMemo(() => {
     void themeEpoch;
     configureTimeMode({
@@ -6662,33 +7599,44 @@ function useViewModel(raw, options, width, scopes, grouping, expanded, snoozes2,
     };
     const sizeTarget = options.sizeTarget === "" ? void 0 : parseSizeTarget(options.sizeTarget);
     const pendingRepos = buildPendingRepoOptions(raw, snoozes2);
+    const reviewedRepos = buildReviewedRepoOptions(raw);
+    const mentionsRepos = buildMentionRepoOptions(raw, snoozes2, reads);
     const openRepos = buildOpenRepoOptions(raw);
     const mergedRepos = buildMergedRepoOptions(raw);
-    const reviewRepos = buildReviewRepoOptions(raw);
+    const reviewRepos2 = buildReviewRepoOptions(raw);
     const sizeRepos = buildSizeRepoOptions(raw);
     const commentRepos = buildCommentRepoOptions(raw);
     const pendingScope = resolveScope(scopes.pending, pendingRepos);
+    const reviewedScope = resolveScope(scopes.reviewed, reviewedRepos);
+    const mentionsScope = resolveScope(scopes.mentions, mentionsRepos);
     const openScope = resolveScope(scopes.open, openRepos);
     const mergedScope = resolveScope(scopes.merged, mergedRepos);
-    const reviewScope = resolveScope(scopes.review, reviewRepos);
+    const reviewScope = resolveScope(scopes.review, reviewRepos2);
     const sizeScope = resolveScope(scopes.size, sizeRepos);
     const commentScope = resolveScope(scopes.comment, commentRepos);
     const review = reviewScope.view === "detail" ? buildReviewView(raw, reviewTarget, reviewScope.repo, width, expanded.review) : null;
     return {
       pendingRepos,
+      reviewedRepos,
+      mentionsRepos,
       openRepos,
       mergedRepos,
-      reviewRepos,
+      reviewRepos: reviewRepos2,
       sizeRepos,
       commentRepos,
       pendingScope,
+      reviewedScope,
+      mentionsScope,
       openScope,
       mergedScope,
       reviewScope,
       sizeScope,
       commentScope,
-      pending: pendingScope.view === "detail" ? buildPendingReviewView(raw, pendingScope.repo, grouping.pending, snoozes2) : null,
+      pending: pendingScope.view === "detail" ? buildPendingReviewView(raw, pendingScope.repo, grouping.pending, snoozes2, reads) : null,
+      reviewed: reviewedScope.view === "detail" ? buildReviewedView(raw, reviewedScope.repo, grouping.reviewed, snoozes2, reads) : null,
+      mentions: mentionsScope.view === "detail" ? buildMentionsView(raw, mentionsScope.repo, grouping.mentions, snoozes2, reads) : null,
       open: openScope.view === "detail" ? buildOpenAuthoredView(raw, openScope.repo, grouping.open) : null,
+      alerts: queueAlerts(raw, snoozes2, reads),
       merged: mergedScope.view === "detail" ? buildMergedView(raw, mergedScope.repo, width, expanded.merged) : null,
       review,
       size: sizeScope.view === "detail" ? buildSizeView(raw, sizeTarget, sizeScope.repo, width) : null,
@@ -6705,16 +7653,21 @@ function useViewModel(raw, options, width, scopes, grouping, expanded, snoozes2,
     options.sizeTarget,
     width,
     scopes.pending,
+    scopes.reviewed,
+    scopes.mentions,
     scopes.open,
     scopes.merged,
     scopes.review,
     scopes.size,
     scopes.comment,
     grouping.pending,
+    grouping.reviewed,
+    grouping.mentions,
     grouping.open,
     expanded.review,
     expanded.merged,
     snoozes2,
+    reads,
     themeEpoch
   ]);
 }
@@ -6821,6 +7774,18 @@ function handleSettingsModalKey(key, context) {
           context.dispatchUi({ type: "cacheActionReported", action: saveNotifications(next) ? "saved" : "notSaved" });
           break;
         }
+        case "trackMentions": {
+          const next = !context.trackMentions;
+          context.setTrackMentions(next);
+          context.dispatchUi({ type: "cacheActionReported", action: saveTrackMentions(next) ? "saved" : "notSaved" });
+          break;
+        }
+        case "notifyMentions": {
+          const next = !context.notifyMentions;
+          context.setNotifyMentions(next);
+          context.dispatchUi({ type: "cacheActionReported", action: saveNotifyMentions(next) ? "saved" : "notSaved" });
+          break;
+        }
         case "notifyChannel": {
           const index = NOTIFY_CHANNELS.indexOf(context.notifyChannel);
           const step = key.name === "left" ? -1 : 1;
@@ -6926,25 +7891,30 @@ function handleThemeModalKey(key, context) {
     }
   }
 }
-function queueTabOf(context) {
-  const { views } = context;
-  if (context.browse.tab === 0) {
+function queueTabOf(key, views) {
+  if (key === "pending") {
+    return { key, view: views?.pending ?? null, repos: views?.pendingRepos ?? [], scope: views?.pendingScope ?? null };
+  }
+  if (key === "reviewed") {
     return {
-      key: "pending",
-      view: views?.pending ?? null,
-      repos: views?.pendingRepos ?? [],
-      scope: views?.pendingScope ?? null
+      key,
+      view: views?.reviewed ?? null,
+      repos: views?.reviewedRepos ?? [],
+      scope: views?.reviewedScope ?? null
     };
   }
-  return {
-    key: "open",
-    view: views?.open ?? null,
-    repos: views?.openRepos ?? [],
-    scope: views?.openScope ?? null
-  };
+  if (key === "mentions") {
+    return {
+      key,
+      view: views?.mentions ?? null,
+      repos: views?.mentionsRepos ?? [],
+      scope: views?.mentionsScope ?? null
+    };
+  }
+  return { key, view: views?.open ?? null, repos: views?.openRepos ?? [], scope: views?.openScope ?? null };
 }
-function handleQueueKey(key, context) {
-  const { key: tab, view, repos, scope } = queueTabOf(context);
+function handleQueueKey(key, queue, context) {
+  const { key: tab, view, repos, scope } = queueTabOf(queue, context.views);
   if (scope?.view === "list") {
     switch (key.name) {
       case "up":
@@ -7003,20 +7973,38 @@ function handleQueueKey(key, context) {
     case "s": {
       const cursor = context.browse.rowCursors[tab];
       const row = rows[Math.min(cursor, rows.length - 1)];
-      if (row.pending === void 0) {
+      const ask = row.pending !== void 0 ? { kind: "review", at: row.pending.requestedAt } : row.mention !== void 0 && row.mention.state !== "read" ? { kind: "mention", at: row.mention.mark.at, ids: row.mention.mark.ids } : null;
+      if (ask === null) {
         break;
       }
-      if (row.pending.snoozed) {
-        context.unsnooze(row.ref);
+      if (row.pending?.snoozed ?? row.mention?.state === "snoozed") {
+        context.unsnooze({ kind: ask.kind, ref: row.ref });
         break;
       }
-      context.dispatchUi({
-        type: "snoozeModalOpened",
-        target: { ref: row.ref, title: row.title, requestedAt: row.pending.requestedAt }
-      });
+      context.dispatchUi({ type: "snoozeModalOpened", target: { ...ask, ref: row.ref, title: row.title } });
       context.beginEdit(context.snoozeDuration);
       break;
     }
+    case "d": {
+      if (key.shift) {
+        const unread = unreadMentionRows(view);
+        if (unread.length > 0) {
+          context.markAllRead(unread);
+        }
+        break;
+      }
+      const cursor = context.browse.rowCursors[tab];
+      const row = rows[Math.min(cursor, rows.length - 1)];
+      if (row.mention === void 0) {
+        break;
+      }
+      if (row.mention.state === "read") {
+        context.markUnread(row);
+      } else {
+        context.markRead(row);
+      }
+      break;
+    }
   }
 }
 function statsTabOf(context) {
@@ -7120,12 +8108,15 @@ function handleAppKey(key, context) {
     context.dispatchBrowse({ type: "tabCycled", delta: -1 });
   } else if (key.name === "right" || key.name === "tab") {
     context.dispatchBrowse({ type: "tabCycled", delta: 1 });
-  } else if (context.browse.tab === 1 && key.name === "t") {
-    context.dispatchBrowse({ type: "subTabToggled" });
-  } else if (context.browse.tab === 0 || context.browse.tab === 1 && context.browse.authoredTab === "open") {
-    handleQueueKey(key, context);
+  } else if ((context.browse.tab === 0 || context.browse.tab === 1) && key.name === "t") {
+    context.dispatchBrowse({ type: "subTabCycled", delta: key.shift ? -1 : 1 });
   } else {
-    handleStatsKey(key, context);
+    const queue = activeQueueTab(context.browse);
+    if (queue === null) {
+      handleStatsKey(key, context);
+    } else {
+      handleQueueKey(key, queue, context);
+    }
   }
 }
 
@@ -7330,10 +8321,13 @@ function App({
   initialAutoReload = false,
   initialReloadInterval = DEFAULT_RELOAD_INTERVAL,
   initialNotifications = false,
+  initialTrackMentions = true,
+  initialNotifyMentions = false,
   initialNotifyChannel = "auto",
   initialCopyLinks = false,
   initialSnoozeDuration = DEFAULT_SNOOZE_DURATION,
   initialSnoozes = [],
+  initialMentionReads = /* @__PURE__ */ new Map(),
   initialTheme = defaultThemeState(),
   openUrl = openInBrowser,
   copyUrl,
@@ -7346,17 +8340,20 @@ function App({
   const copyLink = copyUrl ?? defaultCopyUrl;
   const [ui, dispatchUi] = useReducer(uiReducer, initialUiState);
   const [browse, dispatchBrowse] = useReducer(browseReducer, initialBrowseState);
-  const [options, setOptions] = useState5(initial2);
-  const [saved2, setSaved] = useState5(initialSaved);
-  const [noCache2, setNoCache] = useState5(initialNoCache);
-  const [autoReload2, setAutoReload] = useState5(initialAutoReload);
-  const [reloadInterval2, setReloadInterval] = useState5(initialReloadInterval);
-  const [notifications2, setNotifications] = useState5(initialNotifications);
-  const [notifyChannel2, setNotifyChannel] = useState5(initialNotifyChannel);
-  const [copyLinks2, setCopyLinks] = useState5(initialCopyLinks);
-  const [snoozeDuration2, setSnoozeDuration] = useState5(initialSnoozeDuration);
-  const [themeState, setThemeState] = useState5(initialTheme);
+  const [options, setOptions] = useState6(initial2);
+  const [saved2, setSaved] = useState6(initialSaved);
+  const [noCache2, setNoCache] = useState6(initialNoCache);
+  const [autoReload2, setAutoReload] = useState6(initialAutoReload);
+  const [reloadInterval2, setReloadInterval] = useState6(initialReloadInterval);
+  const [notifications2, setNotifications] = useState6(initialNotifications);
+  const [trackMentions2, setTrackMentions] = useState6(initialTrackMentions);
+  const [notifyMentions2, setNotifyMentions] = useState6(initialNotifyMentions);
+  const [notifyChannel2, setNotifyChannel] = useState6(initialNotifyChannel);
+  const [copyLinks2, setCopyLinks] = useState6(initialCopyLinks);
+  const [snoozeDuration2, setSnoozeDuration] = useState6(initialSnoozeDuration);
+  const [themeState, setThemeState] = useState6(initialTheme);
   const snoozeStore = useSnoozes(initialSnoozes);
+  const readStore = useMentionReads(initialMentionReads);
   const defaultNotify = useMemo2(
     () => createNotifier(notificationBoundary(renderer2), notifyChannel2),
     [renderer2, notifyChannel2]
@@ -7368,9 +8365,38 @@ function App({
     });
     dispatchUi({ type: "successReported", message: `copied ${row.ref} to the clipboard` });
   };
-  const unsnooze = (ref) => {
-    snoozeStore.remove([ref]);
-    dispatchUi({ type: "successReported", message: `unsnoozed ${ref}` });
+  const unsnooze = (target) => {
+    snoozeStore.remove([target]);
+    dispatchUi({ type: "successReported", message: `unsnoozed ${target.ref}` });
+  };
+  const reportMark = (message, saved3) => {
+    if (saved3) {
+      dispatchUi({ type: "successReported", message });
+    } else {
+      dispatchUi({
+        type: "openErrorReported",
+        message: `${message} \xB7 the cache is disabled for this session, so the mark is not saved`
+      });
+    }
+  };
+  const markRead = (row) => {
+    if (row.mention === void 0) {
+      return;
+    }
+    if (row.mention.state === "snoozed") {
+      snoozeStore.remove([{ kind: "mention", ref: row.ref }]);
+    }
+    reportMark(`marked ${row.ref} read`, readStore.markRead(row.ref, row.mention.mark));
+  };
+  const markAllRead = (rows) => {
+    const marks = rows.flatMap((row) => row.mention === void 0 ? [] : [{ ref: row.ref, mark: row.mention.mark }]);
+    reportMark(
+      `marked ${marks.length} ${marks.length === 1 ? "mention" : "mentions"} read`,
+      readStore.markAllRead(marks)
+    );
+  };
+  const markUnread = (row) => {
+    reportMark(`marked ${row.ref} unread`, readStore.markUnread(row.ref));
   };
   useEffect8(() => {
     if (ui.successNotice === null) {
@@ -7383,32 +8409,51 @@ function App({
       clearTimeout(timer);
     };
   }, [ui.successNotice]);
-  const reviewScrollRef = useRef6(null);
-  const sizeScrollRef = useRef6(null);
-  const commentScrollRef = useRef6(null);
-  const mergedScrollRef = useRef6(null);
+  const reviewScrollRef = useRef8(null);
+  const sizeScrollRef = useRef8(null);
+  const commentScrollRef = useRef8(null);
+  const mergedScrollRef = useRef8(null);
   const notifyReviewChanges = useReviewNotifications(notifications2, notifier, (message) => {
     dispatchUi({ type: "openErrorReported", message });
   });
-  const { raw, isSnapshot, loading, load, error, stale, reload } = useLoader(options, noCache2, {
-    onSnapshot: (data) => {
-      notifyReviewChanges(fetchParamsKey(options), data.reviewResults);
+  const notifyMentionChanges = useMentionNotifications(
+    trackMentions2 && notifications2 && notifyMentions2,
+    notifier,
+    (message) => {
+      dispatchUi({ type: "openErrorReported", message });
     },
-    onLoaded: (data) => {
-      dispatchBrowse({
-        type: "dataLoaded",
-        repos: {
-          pending: buildPendingRepoOptions(data),
-          open: buildOpenRepoOptions(data),
-          review: buildReviewRepoOptions(data),
-          size: buildSizeRepoOptions(data),
-          comment: buildCommentRepoOptions(data),
-          merged: buildMergedRepoOptions(data)
-        }
-      });
-      notifyReviewChanges(fetchParamsKey(options), data.reviewResults);
+    !initialNoCache
+  );
+  const baselineKey = (data) => `${fetchParamsKey(options)} ${data.user.toLowerCase()}`;
+  const { raw, isSnapshot, loading, load, error, stale, reload } = useLoader(
+    options,
+    { noCache: noCache2, mentions: trackMentions2 },
+    {
+      onSnapshot: (data) => {
+        readStore.observe(data);
+        notifyReviewChanges(baselineKey(data), data.reviewResults);
+        notifyMentionChanges(baselineKey(data), data.mentions, data.fetchedAt);
+      },
+      onLoaded: (data) => {
+        dispatchBrowse({
+          type: "dataLoaded",
+          repos: {
+            pending: buildPendingRepoOptions(data),
+            reviewed: buildReviewedRepoOptions(data),
+            mentions: buildMentionRepoOptions(data),
+            open: buildOpenRepoOptions(data),
+            review: buildReviewRepoOptions(data),
+            size: buildSizeRepoOptions(data),
+            comment: buildCommentRepoOptions(data),
+            merged: buildMergedRepoOptions(data)
+          }
+        });
+        readStore.observe(data);
+        notifyReviewChanges(baselineKey(data), data.reviewResults);
+        notifyMentionChanges(baselineKey(data), data.mentions, data.fetchedAt);
+      }
     }
-  });
+  );
   useAutoReload(autoReload2 ? reloadIntervalMs(reloadInterval2) : null, loading, reload);
   useSnoozeWakeups(snoozeStore.snoozes, raw !== null, () => {
     if (raw === null) {
@@ -7418,8 +8463,8 @@ function App({
     if (due.length === 0) {
       return;
     }
-    const woken = wokenPrs(due, raw.reviewResults);
-    snoozeStore.remove(due.map((snooze) => snooze.ref));
+    const woken = [...wokenPrs(due, raw.reviewResults), ...wokenMentions(due, raw.mentions ?? [], readStore.reads)];
+    snoozeStore.remove(due);
     if (!notifications2) {
       return;
     }
@@ -7437,10 +8482,11 @@ function App({
     browse.grouped,
     browse.expanded,
     snoozeStore.snoozes,
+    readStore.reads,
     themeState
   );
   const showLoad = useDeferredLoading(loading, isSnapshot ? { showDelay: 0 } : void 0);
-  const draftRef = useRef6("");
+  const draftRef = useRef8("");
   const commitField = () => {
     const field = FIELDS[ui.selectedField];
     const value2 = draftRef.current.trim();
@@ -7501,7 +8547,13 @@ function App({
     const value2 = draftRef.current.trim();
     try {
       const until = Date.now() + parseSnoozeDuration(value2);
-      const saved3 = snoozeStore.add({ ref: target.ref, until, requestedAt: target.requestedAt });
+      const saved3 = snoozeStore.add({
+        kind: target.kind,
+        ref: target.ref,
+        until,
+        at: target.at,
+        ...target.ids === void 0 ? {} : { ids: target.ids }
+      });
       dispatchUi({
         type: "snoozeCommitted",
         message: `snoozed ${target.ref} until ${formatWakeTime(until)}`,
@@ -7540,6 +8592,8 @@ function App({
       autoReload: autoReload2,
       reloadInterval: reloadInterval2,
       notifications: notifications2,
+      trackMentions: trackMentions2,
+      notifyMentions: notifyMentions2,
       notifyChannel: notifyChannel2,
       copyLinks: copyLinks2,
       snoozeDuration: snoozeDuration2,
@@ -7554,6 +8608,8 @@ function App({
       setNoCache,
       setAutoReload,
       setNotifications,
+      setTrackMentions,
+      setNotifyMentions,
       setNotifyChannel,
       setCopyLinks,
       setThemeState,
@@ -7563,6 +8619,9 @@ function App({
       notify: notifier,
       copyRow,
       unsnooze,
+      markRead,
+      markAllRead,
+      markUnread,
       beginEdit: (value2) => {
         draftRef.current = value2;
         dispatchUi({ type: "editStarted" });
@@ -7611,10 +8670,8 @@ function App({
         width,
         modal: ui.modal,
         editing: ui.editing,
-        tab: browse.tab,
-        authoredTab: browse.authoredTab,
+        browse,
         views,
-        pendingCursor: browse.rowCursors.pending,
         copyLinks: copyLinks2,
         openError: ui.openError,
         successNotice: ui.successNotice === null ? null : ui.successNotice.text,
@@ -7631,6 +8688,8 @@ function App({
         autoReload: autoReload2,
         reloadInterval: reloadInterval2,
         notifications: notifications2,
+        trackMentions: trackMentions2,
+        notifyMentions: notifyMentions2,
         notifyChannel: notifyChannel2,
         copyLinks: copyLinks2,
         snoozeDuration: snoozeDuration2,
@@ -7697,10 +8756,13 @@ function bootstrap() {
       autoReload: settings.autoReload === true,
       reloadInterval: settings.reloadInterval ?? DEFAULT_RELOAD_INTERVAL,
       notifications: settings.notifications === true,
+      trackMentions: settings.trackMentions !== false,
+      notifyMentions: settings.notifyMentions === true,
       notifyChannel: settings.notifyChannel ?? "auto",
       copyLinks: settings.copyLinks === true,
       snoozeDuration: settings.snoozeDuration ?? DEFAULT_SNOOZE_DURATION,
       snoozes: readSnoozes(),
+      mentionReads: readMentionReads(),
       theme: theme3,
       json: values.json
     };
@@ -7721,10 +8783,13 @@ var {
   autoReload,
   reloadInterval,
   notifications,
+  trackMentions,
+  notifyMentions,
   notifyChannel,
   copyLinks,
   snoozeDuration,
   snoozes,
+  mentionReads,
   theme: theme2,
   json
 } = bootstrap();
@@ -7749,10 +8814,13 @@ createRoot(renderer).render(
       initialAutoReload: autoReload,
       initialReloadInterval: reloadInterval,
       initialNotifications: notifications,
+      initialTrackMentions: trackMentions,
+      initialNotifyMentions: notifyMentions,
       initialNotifyChannel: notifyChannel,
       initialCopyLinks: copyLinks,
       initialSnoozeDuration: snoozeDuration,
       initialSnoozes: snoozes,
+      initialMentionReads: mentionReads,
       initialTheme: theme2,
       onQuit: () => {
         renderer.destroy();