From 08aa1ee18ed4f5d3abb22698e3981714e6a8086a Mon Sep 17 00:00:00 2001
From: b-at-neu <winkler.b@northeastern.edu>
Date: Fri, 11 Sep 2026 23:48:01 -0400
Subject: [PATCH 01/35] #549 rename manager_digest to manager_daily_digest, add
 weekly

manager_digest shipped in #547 but nothing ever wrote it. Renaming it
now and adding manager_weekly_digest is data-preserving since the
column is still unused.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 lib/constants.ts                                      | 11 ++++++++---
 lib/utils.ts                                          |  4 ++--
 .../migration.sql                                     |  2 ++
 prisma/schema.prisma                                  |  3 ++-
 tests/db/email-log-queries.test.ts                    | 11 +++++++----
 tests/unit/utils.test.ts                              |  4 ++--
 6 files changed, 23 insertions(+), 12 deletions(-)
 create mode 100644 prisma/migrations/20260911222818_manager_digest_cadences/migration.sql

diff --git a/lib/constants.ts b/lib/constants.ts
index 41f72d40..91d10135 100644
--- a/lib/constants.ts
+++ b/lib/constants.ts
@@ -418,7 +418,7 @@ export const EMAIL_STATUS_DESCRIPTIONS: Record<
   sent: 'Handed off to the email provider — delivery not confirmed yet.',
   delivered: null,
   bounced: null,
-  complained: 'The applicant marked this as spam.',
+  complained: 'The recipient marked this as spam.',
   suppressed:
     "Blocked before sending because the address is on the provider's suppression list.",
   failed: 'This was never sent.',
@@ -1123,9 +1123,13 @@ export const EMAIL_TEMPLATE_VALUES = [
   'application_received',
   'application_accepted',
   'application_rejected',
-  'manager_digest',
+  'manager_daily_digest',
+  'manager_weekly_digest',
 ] as const satisfies $Enums.EmailTemplateKey[];
 
+// Keeps a digest run under Resend's 2 req/s (docs.resend.com/api-reference/introduction#rate-limit).
+export const MANAGER_DIGEST_SEND_SPACING_MS = 600;
+
 export const EMAIL_STATUS_LABELS: Record<$Enums.EmailStatus, string> = {
   scheduled: 'Scheduled',
   sent: 'Sent',
@@ -1157,7 +1161,8 @@ export const EMAIL_TEMPLATE_LABELS: Record<$Enums.EmailTemplateKey, string> = {
   application_received: 'Application received',
   application_accepted: 'Application accepted',
   application_rejected: 'Application rejected',
-  manager_digest: 'Manager digest',
+  manager_daily_digest: 'Manager daily digest',
+  manager_weekly_digest: 'Manager weekly digest',
 };
 
 export const EMAIL_STATUS_OPTIONS: {
diff --git a/lib/utils.ts b/lib/utils.ts
index a3b0b553..de6bd0b5 100644
--- a/lib/utils.ts
+++ b/lib/utils.ts
@@ -93,9 +93,9 @@ export function getEmailLogDescription(entry: {
     return EMAIL_STATUS_DESCRIPTIONS[entry.status];
 
   if (entry.bounceType === 'Permanent')
-    return 'The address rejected it permanently — the applicant did not receive this.';
+    return 'The address rejected it permanently — the recipient did not receive this.';
   if (entry.bounceType === 'Transient')
-    return 'Temporarily undeliverable — the applicant did not receive this.';
+    return 'Temporarily undeliverable — the recipient did not receive this.';
   return 'This could not be delivered.';
 }
 
diff --git a/prisma/migrations/20260911222818_manager_digest_cadences/migration.sql b/prisma/migrations/20260911222818_manager_digest_cadences/migration.sql
new file mode 100644
index 00000000..abd083f5
--- /dev/null
+++ b/prisma/migrations/20260911222818_manager_digest_cadences/migration.sql
@@ -0,0 +1,2 @@
+ALTER TYPE "EmailTemplateKey" RENAME VALUE 'manager_digest' TO 'manager_daily_digest';
+ALTER TYPE "EmailTemplateKey" ADD VALUE 'manager_weekly_digest';
diff --git a/prisma/schema.prisma b/prisma/schema.prisma
index d8f89a88..3e807969 100644
--- a/prisma/schema.prisma
+++ b/prisma/schema.prisma
@@ -55,7 +55,8 @@ enum EmailTemplateKey {
   application_received
   application_accepted
   application_rejected
-  manager_digest
+  manager_daily_digest
+  manager_weekly_digest
 }
 
 model User {
diff --git a/tests/db/email-log-queries.test.ts b/tests/db/email-log-queries.test.ts
index 0e749840..904a81a5 100644
--- a/tests/db/email-log-queries.test.ts
+++ b/tests/db/email-log-queries.test.ts
@@ -81,12 +81,15 @@ describe('getEmailLogs / getEmailLogsCount filtering', () => {
     });
     await seedRow({
       to: `${TEST_PREFIX}${marker}-digest@example.com`,
-      template: 'manager_digest',
+      template: 'manager_daily_digest',
     });
 
-    const rows = await getEmailLogs({ q: marker, template: 'manager_digest' });
+    const rows = await getEmailLogs({
+      q: marker,
+      template: 'manager_daily_digest',
+    });
     expect(rows).toHaveLength(1);
-    expect(rows[0]?.template).toBe('manager_digest');
+    expect(rows[0]?.template).toBe('manager_daily_digest');
   });
 
   it('status and template filters compose', async () => {
@@ -99,7 +102,7 @@ describe('getEmailLogs / getEmailLogsCount filtering', () => {
     await seedRow({
       to: `${TEST_PREFIX}${marker}-wrong-template@example.com`,
       status: 'bounced',
-      template: 'manager_digest',
+      template: 'manager_daily_digest',
     });
     await seedRow({
       to: `${TEST_PREFIX}${marker}-wrong-status@example.com`,
diff --git a/tests/unit/utils.test.ts b/tests/unit/utils.test.ts
index 40f57241..af7c75c1 100644
--- a/tests/unit/utils.test.ts
+++ b/tests/unit/utils.test.ts
@@ -1629,14 +1629,14 @@ describe('getEmailLogDescription', () => {
     expect(
       getEmailLogDescription({ status: 'bounced', bounceType: 'Permanent' }),
     ).toBe(
-      'The address rejected it permanently — the applicant did not receive this.',
+      'The address rejected it permanently — the recipient did not receive this.',
     );
   });
 
   it('describes a transient bounce', () => {
     expect(
       getEmailLogDescription({ status: 'bounced', bounceType: 'Transient' }),
-    ).toBe('Temporarily undeliverable — the applicant did not receive this.');
+    ).toBe('Temporarily undeliverable — the recipient did not receive this.');
   });
 
   it('describes a bounce with no bounceType', () => {

From e7fd2d6b54be1e42bafc10d9fe4bc705f0083ff7 Mon Sep 17 00:00:00 2001
From: b-at-neu <winkler.b@northeastern.edu>
Date: Fri, 11 Sep 2026 23:48:05 -0400
Subject: [PATCH 02/35] #549 add org week date helpers

previousOrgDay, currentOrgWeekStart and previousOrgWeek do their
arithmetic on the org calendar date, never a resolved instant, so a
DST transition inside the shifted range can't shift the day count.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 lib/dates.ts             | 48 +++++++++++++++++++++++++++++++
 tests/unit/dates.test.ts | 61 ++++++++++++++++++++++++++++++++++++++++
 2 files changed, 109 insertions(+)

diff --git a/lib/dates.ts b/lib/dates.ts
index 4092230b..75b460cd 100644
--- a/lib/dates.ts
+++ b/lib/dates.ts
@@ -73,6 +73,54 @@ export function toOrgDayString(date: Date): string {
   }).format(date);
 }
 
+// Calendar-date arithmetic on the Y/M/D triple — never on a resolved instant,
+// so a DST transition inside the shifted range can't shift the day count.
+function shiftOrgDay(day: string, deltaDays: number): string {
+  const [year, month, date] = parseOrgDay(day);
+  const shifted = new Date(Date.UTC(year, month - 1, date + deltaDays));
+  return [
+    shifted.getUTCFullYear(),
+    String(shifted.getUTCMonth() + 1).padStart(2, '0'),
+    String(shifted.getUTCDate()).padStart(2, '0'),
+  ].join('-');
+}
+
+/** The org day before `now`'s org day, with its instant bounds. */
+export function previousOrgDay(now: Date): {
+  day: string;
+  start: Date;
+  end: Date;
+} {
+  const day = shiftOrgDay(toOrgDayString(now), -1);
+  return { day, start: orgDayStart(day), end: orgDayEnd(day) };
+}
+
+/** `YYYY-MM-DD` of the Monday of `now`'s org-local week. */
+export function currentOrgWeekStart(now: Date): string {
+  const day = toOrgDayString(now);
+  const [year, month, date] = parseOrgDay(day);
+  const dow = new Date(Date.UTC(year, month - 1, date)).getUTCDay();
+  const daysSinceMonday = (dow + 6) % 7;
+  return shiftOrgDay(day, -daysSinceMonday);
+}
+
+/** The Monday–Sunday org week before `now`'s current week, with its instant bounds. */
+export function previousOrgWeek(now: Date): {
+  startDay: string;
+  endDay: string;
+  start: Date;
+  end: Date;
+} {
+  const startDay = shiftOrgDay(currentOrgWeekStart(now), -7);
+  const endDay = shiftOrgDay(startDay, 6);
+  return {
+    startDay,
+    endDay,
+    start: orgDayStart(startDay),
+    end: orgDayEnd(endDay),
+  };
+}
+
 export function formatInstant(
   date: Date,
   { precision, timeZone }: { precision: DatePrecision; timeZone: string },
diff --git a/tests/unit/dates.test.ts b/tests/unit/dates.test.ts
index a8b09077..9f90eb66 100644
--- a/tests/unit/dates.test.ts
+++ b/tests/unit/dates.test.ts
@@ -1,13 +1,20 @@
 import { describe, expect, it } from 'vitest';
 
 import {
+  currentOrgWeekStart,
   formatInstant,
   formatRelativeTime,
   orgDayEnd,
   orgDayStart,
+  previousOrgDay,
+  previousOrgWeek,
   toOrgDayString,
 } from '@/lib/dates';
 
+function noonOn(day: string): Date {
+  return new Date(orgDayStart(day).getTime() + 12 * 60 * 60 * 1000);
+}
+
 describe('orgDayStart', () => {
   it('resolves a summer day to EDT (UTC-4)', () => {
     expect(orgDayStart('2026-06-30').toISOString()).toBe(
@@ -82,6 +89,60 @@ describe('toOrgDayString', () => {
   });
 });
 
+describe('previousOrgDay', () => {
+  it('returns the org day before now, across the spring-forward transition', () => {
+    const { day, start, end } = previousOrgDay(noonOn('2026-03-09'));
+    expect(day).toBe('2026-03-08');
+    expect(start).toEqual(orgDayStart('2026-03-08'));
+    expect(end).toEqual(orgDayEnd('2026-03-08'));
+  });
+
+  it('returns the org day before now, across the fall-back transition', () => {
+    const { day, start, end } = previousOrgDay(noonOn('2026-11-02'));
+    expect(day).toBe('2026-11-01');
+    expect(start).toEqual(orgDayStart('2026-11-01'));
+    expect(end).toEqual(orgDayEnd('2026-11-01'));
+  });
+
+  it('rolls back across a month boundary', () => {
+    expect(previousOrgDay(noonOn('2026-04-01')).day).toBe('2026-03-31');
+  });
+});
+
+describe('currentOrgWeekStart', () => {
+  it('resolves a Sunday to the Monday that started its week', () => {
+    expect(currentOrgWeekStart(noonOn('2026-03-08'))).toBe('2026-03-02');
+  });
+
+  it('resolves a Monday to itself', () => {
+    expect(currentOrgWeekStart(noonOn('2026-03-09'))).toBe('2026-03-09');
+  });
+});
+
+describe('previousOrgWeek', () => {
+  it('spans a full Monday-Sunday week before the current one', () => {
+    const week = previousOrgWeek(noonOn('2026-03-23'));
+    expect(week.startDay).toBe('2026-03-16');
+    expect(week.endDay).toBe('2026-03-22');
+    expect(week.start).toEqual(orgDayStart('2026-03-16'));
+    expect(week.end).toEqual(orgDayEnd('2026-03-22'));
+  });
+
+  it('still spans exactly 7 calendar days across a DST change', () => {
+    // now's current week is 2026-03-09..15, so the previous week is
+    // 2026-03-02..08 — the Sunday it ends on is the spring-forward day.
+    const week = previousOrgWeek(noonOn('2026-03-09'));
+    expect(week.startDay).toBe('2026-03-02');
+    expect(week.endDay).toBe('2026-03-08');
+
+    // Spring-forward inside the week loses an hour, so the instant span is
+    // 167 hours, not 168 — the calendar-day count is still exactly 7.
+    const hours =
+      (week.end.getTime() - week.start.getTime() + 1) / (1000 * 60 * 60);
+    expect(hours).toBeCloseTo(167, 5);
+  });
+});
+
 describe('formatInstant', () => {
   const date = new Date('2026-06-30T23:30:00.000Z');
 

From 8b1a547db2d22ba066b4c3f3f2dedd6f40ef4606 Mon Sep 17 00:00:00 2001
From: b-at-neu <winkler.b@northeastern.edu>
Date: Fri, 11 Sep 2026 23:48:11 -0400
Subject: [PATCH 03/35] #549 add manager digest recipient queries and templates
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

getDailyDigestRecipients/getWeeklyDigestRecipients compute recipients
from EmailLog alone (no new column) — a manager already digested
inside the current calendar day/week is dropped and counted as
skipped, so a repeat cron fire is a no-op.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 lib/email/templates.ts             | 208 +++++++++++++++++++++++
 lib/types.ts                       |  31 ++++
 prisma/data/digests.ts             | 263 +++++++++++++++++++++++++++++
 tests/unit/email-templates.test.ts | 176 +++++++++++++++++++
 4 files changed, 678 insertions(+)
 create mode 100644 prisma/data/digests.ts

diff --git a/lib/email/templates.ts b/lib/email/templates.ts
index 28c39421..f8592b83 100644
--- a/lib/email/templates.ts
+++ b/lib/email/templates.ts
@@ -1,6 +1,12 @@
 import 'server-only';
 
 import { getBaseUrl } from '@/lib/base-url';
+import { APPLICATION_STATUS_LABELS, ORG_TIMEZONE } from '@/lib/constants';
+import { orgDayStart } from '@/lib/dates';
+import {
+  type ManagerDigestPosition,
+  type WeeklyDigestStatusCount,
+} from '@/lib/types';
 
 // Inline styles throughout: email clients ignore Tailwind classes.
 
@@ -248,3 +254,205 @@ export function applicationDecisionEmail({
     text,
   };
 }
+
+export const MANAGER_EMAIL_FOOTER =
+  'You&#39;re receiving this because you manage one or more positions on Aplio.';
+
+function pluralize(count: number, singular: string): string {
+  return count === 1 ? singular : `${singular}s`;
+}
+
+function formatDigestDay(day: string): string {
+  return new Intl.DateTimeFormat('en-US', {
+    timeZone: ORG_TIMEZONE,
+    month: 'short',
+    day: 'numeric',
+    year: 'numeric',
+  }).format(orgDayStart(day));
+}
+
+function formatDigestWeekRange(startDay: string, endDay: string): string {
+  const startLabel = new Intl.DateTimeFormat('en-US', {
+    timeZone: ORG_TIMEZONE,
+    month: 'short',
+    day: 'numeric',
+  }).format(orgDayStart(startDay));
+  const endLabel = new Intl.DateTimeFormat('en-US', {
+    timeZone: ORG_TIMEZONE,
+    month: 'short',
+    day: 'numeric',
+    year: 'numeric',
+  }).format(orgDayStart(endDay));
+  return `${startLabel} – ${endLabel}`;
+}
+
+export interface ManagerDailyDigestEmailOptions {
+  firstName?: string;
+  day: string;
+  positions: ManagerDigestPosition[];
+  total: number;
+}
+
+export function managerDailyDigestEmail({
+  firstName,
+  day,
+  positions,
+  total,
+}: ManagerDailyDigestEmailOptions): EmailTemplate {
+  const baseUrl = getBaseUrl();
+  const allApplicationsUrl = `${baseUrl}/manage/applications`;
+  const dayLabel = formatDigestDay(day);
+  const safeGreeting = escapeHtml(greeting(firstName));
+
+  const subject =
+    positions.length === 1
+      ? `${total} new ${pluralize(total, 'application')} for ${positions[0]!.title}`
+      : `${total} new applications across ${positions.length} positions`;
+
+  const positionRows = positions
+    .map((position) => {
+      const url = `${allApplicationsUrl}?positionId=${position.positionId}`;
+      return `<p style="margin:0 0 8px;font-size:14px;color:#09090b;"><a href="${escapeHtml(url)}" style="color:#D41B2C;text-decoration:none;font-weight:600;">${escapeHtml(position.title)}</a> — ${position.newApplications} new ${pluralize(position.newApplications, 'application')}</p>`;
+    })
+    .join('\n');
+
+  const content = `
+    <p style="margin:0 0 16px;font-size:14px;color:#09090b;">${safeGreeting}</p>
+    <p style="margin:0 0 16px;font-size:14px;color:#71717a;">New applications on the positions you manage, from <strong>${escapeHtml(dayLabel)}</strong>.</p>
+    <div style="margin:0 0 24px;">${positionRows}</div>
+    ${primaryButton(allApplicationsUrl, 'Review all applications')}
+  `;
+
+  const text = [
+    greeting(firstName),
+    '',
+    `New applications on the positions you manage, from ${dayLabel}.`,
+    '',
+    ...positions.map(
+      (position) =>
+        `${position.title} — ${position.newApplications} new ${pluralize(position.newApplications, 'application')}: ${allApplicationsUrl}?positionId=${position.positionId}`,
+    ),
+    '',
+    `Review all applications: ${allApplicationsUrl}`,
+  ].join('\n');
+
+  return {
+    subject,
+    html: emailLayout({
+      title: 'Manager daily digest',
+      content,
+      footer: MANAGER_EMAIL_FOOTER,
+    }),
+    text,
+  };
+}
+
+export interface ManagerWeeklyDigestEmailOptions {
+  firstName?: string;
+  weekStart: string;
+  weekEnd: string;
+  newApplications: number;
+  statusCounts: WeeklyDigestStatusCount[];
+  openPositions: Pick<ManagerDigestPosition, 'positionId' | 'title'>[];
+}
+
+export function managerWeeklyDigestEmail({
+  firstName,
+  weekStart,
+  weekEnd,
+  newApplications,
+  statusCounts,
+  openPositions,
+}: ManagerWeeklyDigestEmailOptions): EmailTemplate {
+  const baseUrl = getBaseUrl();
+  const allApplicationsUrl = `${baseUrl}/manage/applications`;
+  const weekRangeLabel = formatDigestWeekRange(weekStart, weekEnd);
+  const safeGreeting = escapeHtml(greeting(firstName));
+  const unresolvedTotal = statusCounts.reduce(
+    (sum, entry) => sum + entry.count,
+    0,
+  );
+
+  const subject =
+    newApplications > 0
+      ? `Your week on Aplio: ${newApplications} new ${pluralize(newApplications, 'application')}`
+      : `Your week on Aplio: ${unresolvedTotal} ${pluralize(unresolvedTotal, 'application')} awaiting review`;
+
+  const newThisWeekLine =
+    newApplications > 0
+      ? `${newApplications} new ${pluralize(newApplications, 'application')} across the positions you manage.`
+      : 'No new applications this week.';
+
+  const statusRows =
+    statusCounts.length > 0
+      ? statusCounts
+          .map((entry) => {
+            const url = `${allApplicationsUrl}?status=${entry.status}`;
+            return `<a href="${escapeHtml(url)}" style="color:#D41B2C;text-decoration:none;font-weight:600;">${escapeHtml(APPLICATION_STATUS_LABELS[entry.status])}</a> — ${entry.count}`;
+          })
+          .join('<br />')
+      : 'No applications on your positions yet.';
+
+  const openPositionsLine =
+    openPositions.length > 0
+      ? openPositions
+          .map((position) => {
+            const url = `${allApplicationsUrl}?positionId=${position.positionId}`;
+            return `<a href="${escapeHtml(url)}" style="color:#D41B2C;text-decoration:none;font-weight:600;">${escapeHtml(position.title)}</a>`;
+          })
+          .join(' · ')
+      : 'You have no positions open right now.';
+
+  const content = `
+    <p style="margin:0 0 16px;font-size:14px;color:#09090b;">${safeGreeting}</p>
+    <p style="margin:0 0 16px;font-size:14px;color:#71717a;">Your weekly summary for <strong>${escapeHtml(weekRangeLabel)}</strong>.</p>
+    <p style="margin:0 0 4px;font-size:14px;font-weight:700;color:#09090b;">New this week</p>
+    <p style="margin:0 0 16px;font-size:14px;color:#71717a;">${escapeHtml(newThisWeekLine)}</p>
+    <p style="margin:0 0 4px;font-size:14px;font-weight:700;color:#09090b;">Where things stand</p>
+    <p style="margin:0 0 16px;font-size:14px;color:#71717a;">${statusRows}</p>
+    <p style="margin:0 0 4px;font-size:14px;font-weight:700;color:#09090b;">Your open positions</p>
+    <p style="margin:0 0 24px;font-size:14px;color:#71717a;">${openPositionsLine}</p>
+    ${primaryButton(allApplicationsUrl, 'Review all applications')}
+  `;
+
+  const text = [
+    greeting(firstName),
+    '',
+    `Your weekly summary for ${weekRangeLabel}.`,
+    '',
+    'New this week',
+    newThisWeekLine,
+    '',
+    'Where things stand',
+    statusCounts.length > 0
+      ? statusCounts
+          .map(
+            (entry) =>
+              `${APPLICATION_STATUS_LABELS[entry.status]} (${allApplicationsUrl}?status=${entry.status}) — ${entry.count}`,
+          )
+          .join('\n')
+      : 'No applications on your positions yet.',
+    '',
+    'Your open positions',
+    openPositions.length > 0
+      ? openPositions
+          .map(
+            (position) =>
+              `${position.title}: ${allApplicationsUrl}?positionId=${position.positionId}`,
+          )
+          .join('\n')
+      : 'You have no positions open right now.',
+    '',
+    `Review all applications: ${allApplicationsUrl}`,
+  ].join('\n');
+
+  return {
+    subject,
+    html: emailLayout({
+      title: 'Manager weekly digest',
+      content,
+      footer: MANAGER_EMAIL_FOOTER,
+    }),
+    text,
+  };
+}
diff --git a/lib/types.ts b/lib/types.ts
index f4983db7..c375b33e 100644
--- a/lib/types.ts
+++ b/lib/types.ts
@@ -527,3 +527,34 @@ export type EmailLogListItem = Prisma.EmailLogGetPayload<{
 
 export type EmailFailureStatus = (typeof EMAIL_FAILURE_STATUSES)[number];
 export type EmailFailureCounts = Record<EmailFailureStatus, number>;
+
+export type ManagerDigestPosition = {
+  positionId: string;
+  title: string;
+  newApplications: number;
+};
+
+export type DailyDigestRecipient = {
+  userId: string;
+  email: string;
+  name: string | null;
+  day: string;
+  positions: ManagerDigestPosition[];
+  total: number;
+};
+
+export type WeeklyDigestStatusCount = {
+  status: $Enums.ApplicationStatus;
+  count: number;
+};
+
+export type WeeklyDigestRecipient = {
+  userId: string;
+  email: string;
+  name: string | null;
+  weekStart: string;
+  weekEnd: string;
+  newApplications: number;
+  statusCounts: WeeklyDigestStatusCount[];
+  openPositions: Pick<ManagerDigestPosition, 'positionId' | 'title'>[];
+};
diff --git a/prisma/data/digests.ts b/prisma/data/digests.ts
new file mode 100644
index 00000000..43fde2c9
--- /dev/null
+++ b/prisma/data/digests.ts
@@ -0,0 +1,263 @@
+import 'server-only';
+
+import { type $Enums } from '@/prisma/client';
+
+import {
+  NON_REVIEWABLE_APPLICATION_STATUSES,
+  PUBLISHED_POSITION_WHERE,
+  REVIEWER_APPLICATION_STATUSES,
+  UNRESOLVED_APPLICATION_STATUSES,
+} from '@/lib/constants';
+import {
+  currentOrgWeekStart,
+  orgDayStart,
+  previousOrgDay,
+  previousOrgWeek,
+  toOrgDayString,
+} from '@/lib/dates';
+import { prisma } from '@/lib/prisma';
+import {
+  type DailyDigestRecipient,
+  type ManagerDigestPosition,
+  type WeeklyDigestRecipient,
+} from '@/lib/types';
+import { isAcceptingApplications } from '@/lib/utils';
+
+type ManagerCandidate = {
+  id: string;
+  email: string;
+  name: string | null;
+  managedPositions: {
+    id: string;
+    title: string;
+    status: $Enums.PositionStatus;
+    opensAt: Date | null;
+    closesAt: Date | null;
+  }[];
+};
+
+// Scoped by the `managers` relation only — never buildReviewablePositionWhere,
+// whose admin short-circuit would hand an admin every position.
+async function getManagerCandidates(): Promise<ManagerCandidate[]> {
+  return prisma.user.findMany({
+    where: {
+      deletedAt: null,
+      managedPositions: { some: PUBLISHED_POSITION_WHERE },
+    },
+    select: {
+      id: true,
+      email: true,
+      name: true,
+      managedPositions: {
+        where: PUBLISHED_POSITION_WHERE,
+        select: {
+          id: true,
+          title: true,
+          status: true,
+          opensAt: true,
+          closesAt: true,
+        },
+      },
+    },
+  });
+}
+
+async function tallyNewApplications(
+  positionIds: string[],
+  start: Date,
+  end: Date,
+): Promise<Map<string, number>> {
+  if (positionIds.length === 0) return new Map();
+
+  const rows = await prisma.application.groupBy({
+    by: ['positionId'],
+    where: {
+      positionId: { in: positionIds },
+      deletedAt: null,
+      status: { notIn: NON_REVIEWABLE_APPLICATION_STATUSES },
+      submittedAt: { gte: start, lte: end },
+      position: PUBLISHED_POSITION_WHERE,
+    },
+    _count: true,
+  });
+
+  return new Map(rows.map((row) => [row.positionId, row._count]));
+}
+
+async function tallyStatusBreakdown(
+  positionIds: string[],
+): Promise<Map<string, Map<$Enums.ApplicationStatus, number>>> {
+  const map = new Map<string, Map<$Enums.ApplicationStatus, number>>();
+  if (positionIds.length === 0) return map;
+
+  const rows = await prisma.application.groupBy({
+    by: ['positionId', 'status'],
+    where: {
+      positionId: { in: positionIds },
+      deletedAt: null,
+      status: { notIn: NON_REVIEWABLE_APPLICATION_STATUSES },
+      position: PUBLISHED_POSITION_WHERE,
+    },
+    _count: true,
+  });
+
+  for (const row of rows) {
+    const existing = map.get(row.positionId) ?? new Map();
+    existing.set(row.status, row._count);
+    map.set(row.positionId, existing);
+  }
+
+  return map;
+}
+
+/**
+ * Managers with at least one new application on a managed position over the
+ * previous org calendar day, gated so a manager already digested today is
+ * dropped (and counted in `skipped`) rather than emailed twice.
+ */
+export async function getDailyDigestRecipients(
+  now: Date = new Date(),
+): Promise<{ recipients: DailyDigestRecipient[]; skipped: number }> {
+  const managers = await getManagerCandidates();
+  if (managers.length === 0) return { recipients: [], skipped: 0 };
+
+  const managerIds = managers.map((manager) => manager.id);
+  const { day, start, end } = previousOrgDay(now);
+
+  const alreadyDigested = await prisma.emailLog.findMany({
+    where: {
+      template: 'manager_daily_digest',
+      userId: { in: managerIds },
+      createdAt: { gte: orgDayStart(toOrgDayString(now)) },
+    },
+    select: { userId: true },
+  });
+  const gatedIds = new Set(
+    alreadyDigested.map((row) => row.userId).filter((id) => id !== null),
+  );
+
+  const candidates = managers.filter((manager) => !gatedIds.has(manager.id));
+  if (candidates.length === 0)
+    return { recipients: [], skipped: gatedIds.size };
+
+  const positionIds = candidates.flatMap((manager) =>
+    manager.managedPositions.map((position) => position.id),
+  );
+  const tallies = await tallyNewApplications(positionIds, start, end);
+
+  const recipients: DailyDigestRecipient[] = [];
+  for (const manager of candidates) {
+    const positions: ManagerDigestPosition[] = manager.managedPositions
+      .map((position) => ({
+        positionId: position.id,
+        title: position.title,
+        newApplications: tallies.get(position.id) ?? 0,
+      }))
+      .filter((position) => position.newApplications > 0)
+      .sort((a, b) => a.title.localeCompare(b.title));
+
+    const total = positions.reduce(
+      (sum, position) => sum + position.newApplications,
+      0,
+    );
+    if (total === 0) continue;
+
+    recipients.push({
+      userId: manager.id,
+      email: manager.email,
+      name: manager.name,
+      day,
+      positions,
+      total,
+    });
+  }
+
+  return { recipients, skipped: gatedIds.size };
+}
+
+/**
+ * Managers with new applications or anything unresolved on a managed
+ * position over the previous org Monday-Sunday week. Same per-period gate
+ * shape as the daily digest, keyed to `manager_weekly_digest` rows.
+ */
+export async function getWeeklyDigestRecipients(
+  now: Date = new Date(),
+): Promise<{ recipients: WeeklyDigestRecipient[]; skipped: number }> {
+  const managers = await getManagerCandidates();
+  if (managers.length === 0) return { recipients: [], skipped: 0 };
+
+  const managerIds = managers.map((manager) => manager.id);
+  const { startDay, endDay, start, end } = previousOrgWeek(now);
+
+  const alreadyDigested = await prisma.emailLog.findMany({
+    where: {
+      template: 'manager_weekly_digest',
+      userId: { in: managerIds },
+      createdAt: { gte: orgDayStart(currentOrgWeekStart(now)) },
+    },
+    select: { userId: true },
+  });
+  const gatedIds = new Set(
+    alreadyDigested.map((row) => row.userId).filter((id) => id !== null),
+  );
+
+  const candidates = managers.filter((manager) => !gatedIds.has(manager.id));
+  if (candidates.length === 0)
+    return { recipients: [], skipped: gatedIds.size };
+
+  const positionIds = candidates.flatMap((manager) =>
+    manager.managedPositions.map((position) => position.id),
+  );
+
+  const [newTallies, statusTallies] = await Promise.all([
+    tallyNewApplications(positionIds, start, end),
+    tallyStatusBreakdown(positionIds),
+  ]);
+
+  const unresolvedStatuses: readonly $Enums.ApplicationStatus[] =
+    UNRESOLVED_APPLICATION_STATUSES;
+
+  const recipients: WeeklyDigestRecipient[] = [];
+  for (const manager of candidates) {
+    const managerPositionIds = manager.managedPositions.map(
+      (position) => position.id,
+    );
+
+    const newApplications = managerPositionIds.reduce(
+      (sum, id) => sum + (newTallies.get(id) ?? 0),
+      0,
+    );
+
+    const statusCounts = REVIEWER_APPLICATION_STATUSES.map((status) => ({
+      status,
+      count: managerPositionIds.reduce(
+        (sum, id) => sum + (statusTallies.get(id)?.get(status) ?? 0),
+        0,
+      ),
+    })).filter((entry) => entry.count > 0);
+
+    const unresolvedTotal = statusCounts
+      .filter((entry) => unresolvedStatuses.includes(entry.status))
+      .reduce((sum, entry) => sum + entry.count, 0);
+
+    if (newApplications === 0 && unresolvedTotal === 0) continue;
+
+    const openPositions = manager.managedPositions
+      .filter((position) => isAcceptingApplications(position))
+      .map((position) => ({ positionId: position.id, title: position.title }))
+      .sort((a, b) => a.title.localeCompare(b.title));
+
+    recipients.push({
+      userId: manager.id,
+      email: manager.email,
+      name: manager.name,
+      weekStart: startDay,
+      weekEnd: endDay,
+      newApplications,
+      statusCounts,
+      openPositions,
+    });
+  }
+
+  return { recipients, skipped: gatedIds.size };
+}
diff --git a/tests/unit/email-templates.test.ts b/tests/unit/email-templates.test.ts
index c2c55062..d613002b 100644
--- a/tests/unit/email-templates.test.ts
+++ b/tests/unit/email-templates.test.ts
@@ -2,10 +2,13 @@ import { describe, expect, it } from 'vitest';
 
 import {
   APPLICANT_EMAIL_FOOTER,
+  MANAGER_EMAIL_FOOTER,
   applicationDecisionEmail,
   applicationReceivedEmail,
   emailLayout,
   escapeHtml,
+  managerDailyDigestEmail,
+  managerWeeklyDigestEmail,
   otpEmail,
 } from '@/lib/email/templates';
 
@@ -175,3 +178,176 @@ describe('applicationDecisionEmail', () => {
     expect(result.html).toContain(APPLICANT_EMAIL_FOOTER);
   });
 });
+
+describe('managerDailyDigestEmail', () => {
+  it('singularizes the subject and body at exactly 1', () => {
+    const result = managerDailyDigestEmail({
+      firstName: 'Jane',
+      day: '2026-03-02',
+      positions: [
+        { positionId: 'pos-1', title: 'Treasurer', newApplications: 1 },
+      ],
+      total: 1,
+    });
+    expect(result.subject).toBe('1 new application for Treasurer');
+    expect(result.html).toContain('1 new application<');
+  });
+
+  it('names the single position in the subject, pluralized', () => {
+    const result = managerDailyDigestEmail({
+      day: '2026-03-02',
+      positions: [
+        { positionId: 'pos-1', title: 'Treasurer', newApplications: 3 },
+      ],
+      total: 3,
+    });
+    expect(result.subject).toBe('3 new applications for Treasurer');
+  });
+
+  it('summarizes across positions in the subject when there is more than one', () => {
+    const result = managerDailyDigestEmail({
+      day: '2026-03-02',
+      positions: [
+        { positionId: 'pos-1', title: 'Senator', newApplications: 3 },
+        { positionId: 'pos-2', title: 'Treasurer', newApplications: 2 },
+      ],
+      total: 5,
+    });
+    expect(result.subject).toBe('5 new applications across 2 positions');
+  });
+
+  it('escapes a dangerous position title in the html but leaves the subject raw', () => {
+    const result = managerDailyDigestEmail({
+      day: '2026-03-02',
+      positions: [
+        { positionId: 'pos-1', title: DANGEROUS_TITLE, newApplications: 1 },
+      ],
+      total: 1,
+    });
+    expect(result.subject).toBe(`1 new application for ${DANGEROUS_TITLE}`);
+    expect(result.html).toContain(escapeHtml(DANGEROUS_TITLE));
+    expect(result.html).not.toContain(DANGEROUS_TITLE);
+    expect(result.text).toContain(DANGEROUS_TITLE);
+  });
+
+  it('links every position row to its own positionId', () => {
+    const result = managerDailyDigestEmail({
+      day: '2026-03-02',
+      positions: [
+        { positionId: 'pos-1', title: 'Senator', newApplications: 3 },
+        { positionId: 'pos-2', title: 'Treasurer', newApplications: 2 },
+      ],
+      total: 5,
+    });
+    expect(result.html).toContain('?positionId=pos-1');
+    expect(result.html).toContain('?positionId=pos-2');
+    expect(result.text).toContain('?positionId=pos-1');
+    expect(result.text).toContain('?positionId=pos-2');
+  });
+
+  it('names the org day and includes the manager footer', () => {
+    const result = managerDailyDigestEmail({
+      day: '2026-03-02',
+      positions: [
+        { positionId: 'pos-1', title: 'Treasurer', newApplications: 1 },
+      ],
+      total: 1,
+    });
+    expect(result.html).toContain('Mar 2, 2026');
+    expect(result.html).toContain(MANAGER_EMAIL_FOOTER);
+  });
+});
+
+describe('managerWeeklyDigestEmail', () => {
+  const base = {
+    weekStart: '2026-03-02',
+    weekEnd: '2026-03-08',
+    openPositions: [],
+  };
+
+  it('uses the new-applications subject when there is new activity', () => {
+    const result = managerWeeklyDigestEmail({
+      ...base,
+      newApplications: 12,
+      statusCounts: [],
+    });
+    expect(result.subject).toBe('Your week on Aplio: 12 new applications');
+  });
+
+  it('singularizes the new-applications subject at exactly 1', () => {
+    const result = managerWeeklyDigestEmail({
+      ...base,
+      newApplications: 1,
+      statusCounts: [],
+    });
+    expect(result.subject).toBe('Your week on Aplio: 1 new application');
+  });
+
+  it('falls back to the awaiting-review subject with no new applications', () => {
+    const result = managerWeeklyDigestEmail({
+      ...base,
+      newApplications: 0,
+      statusCounts: [{ status: 'applied', count: 7 }],
+    });
+    expect(result.subject).toBe(
+      'Your week on Aplio: 7 applications awaiting review',
+    );
+  });
+
+  it('omits zero-count statuses and links each remaining status', () => {
+    const result = managerWeeklyDigestEmail({
+      ...base,
+      newApplications: 0,
+      statusCounts: [
+        { status: 'applied', count: 7 },
+        { status: 'accepted', count: 3 },
+      ],
+    });
+    expect(result.html).toContain('?status=applied');
+    expect(result.html).toContain('?status=accepted');
+    expect(result.html).not.toContain('?status=rejected');
+  });
+
+  it('shows the empty statuses line when nothing is unresolved but new applications exist', () => {
+    const result = managerWeeklyDigestEmail({
+      ...base,
+      newApplications: 4,
+      statusCounts: [],
+    });
+    expect(result.html).toContain('No applications on your positions yet.');
+  });
+
+  it('shows the empty open-positions line with none open', () => {
+    const result = managerWeeklyDigestEmail({
+      ...base,
+      newApplications: 4,
+      statusCounts: [],
+    });
+    expect(result.html).toContain('You have no positions open right now.');
+  });
+
+  it('links open positions by positionId', () => {
+    const result = managerWeeklyDigestEmail({
+      ...base,
+      newApplications: 4,
+      statusCounts: [],
+      openPositions: [
+        { positionId: 'pos-1', title: 'Senator' },
+        { positionId: 'pos-2', title: 'Treasurer' },
+      ],
+    });
+    expect(result.html).toContain('?positionId=pos-1');
+    expect(result.html).toContain('?positionId=pos-2');
+  });
+
+  it('includes the week range and the manager footer', () => {
+    const result = managerWeeklyDigestEmail({
+      ...base,
+      newApplications: 4,
+      statusCounts: [],
+    });
+    expect(result.html).toContain('Mar 2');
+    expect(result.html).toContain('Mar 8, 2026');
+    expect(result.html).toContain(MANAGER_EMAIL_FOOTER);
+  });
+});

From 09653ccd382368ba622a288722befe806f396ef6 Mon Sep 17 00:00:00 2001
From: b-at-neu <winkler.b@northeastern.edu>
Date: Fri, 11 Sep 2026 23:48:20 -0400
Subject: [PATCH 04/35] #549 add manager digest cron routes
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Two static routes, not one route with a mode param — each names and
runs exactly the one digest its path names, so it stays a falsifiable
allowlist line rather than a job runner. Both reject any request whose
Authorization header isn't the CRON_SECRET bearer token before
touching the database.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .env.example                                |   4 +
 README.md                                   |  19 +-
 app/api/cron/manager-daily-digest/route.ts  |  11 +
 app/api/cron/manager-weekly-digest/route.ts |  11 +
 lib/cron.ts                                 |  14 +
 lib/email/manager-digests.ts                |  93 +++++
 tests/db/manager-digests.test.ts            | 374 ++++++++++++++++++++
 vercel.json                                 |   6 +-
 8 files changed, 522 insertions(+), 10 deletions(-)
 create mode 100644 app/api/cron/manager-daily-digest/route.ts
 create mode 100644 app/api/cron/manager-weekly-digest/route.ts
 create mode 100644 lib/cron.ts
 create mode 100644 lib/email/manager-digests.ts
 create mode 100644 tests/db/manager-digests.test.ts

diff --git a/.env.example b/.env.example
index b7a5abc1..6f896546 100644
--- a/.env.example
+++ b/.env.example
@@ -18,6 +18,10 @@ RESEND_FROM_EMAIL=
 # Signing secret for the Resend webhook's endpoint (Resend dashboard → the webhook).
 RESEND_WEBHOOK_SECRET=
 
+# Shared secret Vercel Cron sends as `Authorization: Bearer <value>` — verified
+# by the manager-digest cron routes (app/api/cron/manager-{daily,weekly}-digest).
+CRON_SECRET=
+
 # Dev-bypass login (see lib/utils.ts#isBypassAllowed) is disabled by default
 # on any host, including production deployments not on Vercel. This repo's
 # `dev` script is plain `next dev --turbopack` (no Vercel CLI), so VERCEL_ENV
diff --git a/README.md b/README.md
index e5c3e88f..840cdfa8 100644
--- a/README.md
+++ b/README.md
@@ -30,15 +30,16 @@ cp .env.example .env.local
 
 Open `.env.local` and fill in the required variables:
 
-| Variable                | Description                                                                                                                                                                                 |
-| ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `DATABASE_URL`          | Postgres connection string (pooled). Local Docker: `postgresql://admin:admin@localhost:5432/aplio`                                                                                          |
-| `DIRECT_URL`            | Direct (non-pooled) connection string. Local Docker: same as `DATABASE_URL`                                                                                                                 |
-| `BETTER_AUTH_SECRET`    | Signs session cookies. At least 32 characters: `openssl rand -base64 32`                                                                                                                    |
-| `BETTER_AUTH_URL`       | Production only, pinned to the real domain. Preview/local derive it from `VERCEL_URL`, else `http://localhost:3000`. Also governs the absolute URLs (logo, sign-in link) in outgoing email. |
-| `RESEND_API_KEY`        | Resend API key for transactional email delivery                                                                                                                                             |
-| `RESEND_FROM_EMAIL`     | Verified sender address in Resend (e.g. `noreply@yourdomain.com`)                                                                                                                           |
-| `RESEND_WEBHOOK_SECRET` | Signing secret for the Resend webhook that reports delivery events (Resend dashboard → the webhook)                                                                                         |
+| Variable                | Description                                                                                                                                                                                              |
+| ----------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `DATABASE_URL`          | Postgres connection string (pooled). Local Docker: `postgresql://admin:admin@localhost:5432/aplio`                                                                                                       |
+| `DIRECT_URL`            | Direct (non-pooled) connection string. Local Docker: same as `DATABASE_URL`                                                                                                                              |
+| `BETTER_AUTH_SECRET`    | Signs session cookies. At least 32 characters: `openssl rand -base64 32`                                                                                                                                 |
+| `BETTER_AUTH_URL`       | Production only, pinned to the real domain. Preview/local derive it from `VERCEL_URL`, else `http://localhost:3000`. Also governs the absolute URLs (logo, sign-in link) in outgoing email.              |
+| `RESEND_API_KEY`        | Resend API key for transactional email delivery                                                                                                                                                          |
+| `RESEND_FROM_EMAIL`     | Verified sender address in Resend (e.g. `noreply@yourdomain.com`)                                                                                                                                        |
+| `RESEND_WEBHOOK_SECRET` | Signing secret for the Resend webhook that reports delivery events (Resend dashboard → the webhook)                                                                                                      |
+| `CRON_SECRET`           | Bearer secret Vercel Cron sends as `Authorization: Bearer …`; verified by the manager-digest cron routes. Set it in the Vercel project env (`openssl rand -base64 32`) or both routes reject every call. |
 
 > **Note:** Prisma CLI commands (`prisma:migrate`, `prisma:seed`) read from `.env`; Next.js reads `.env.local`. Both files are gitignored. For local development you can keep the same values in both.
 
diff --git a/app/api/cron/manager-daily-digest/route.ts b/app/api/cron/manager-daily-digest/route.ts
new file mode 100644
index 00000000..e0ad389f
--- /dev/null
+++ b/app/api/cron/manager-daily-digest/route.ts
@@ -0,0 +1,11 @@
+import { rejectUnauthorizedCron } from '@/lib/cron';
+import { dispatchDailyManagerDigests } from '@/lib/email/manager-digests';
+
+export const maxDuration = 300;
+
+export async function GET(request: Request): Promise<Response> {
+  const denied = rejectUnauthorizedCron(request);
+  if (denied) return denied;
+
+  return Response.json(await dispatchDailyManagerDigests());
+}
diff --git a/app/api/cron/manager-weekly-digest/route.ts b/app/api/cron/manager-weekly-digest/route.ts
new file mode 100644
index 00000000..db50145f
--- /dev/null
+++ b/app/api/cron/manager-weekly-digest/route.ts
@@ -0,0 +1,11 @@
+import { rejectUnauthorizedCron } from '@/lib/cron';
+import { dispatchWeeklyManagerDigests } from '@/lib/email/manager-digests';
+
+export const maxDuration = 300;
+
+export async function GET(request: Request): Promise<Response> {
+  const denied = rejectUnauthorizedCron(request);
+  if (denied) return denied;
+
+  return Response.json(await dispatchWeeklyManagerDigests());
+}
diff --git a/lib/cron.ts b/lib/cron.ts
new file mode 100644
index 00000000..4b0e0416
--- /dev/null
+++ b/lib/cron.ts
@@ -0,0 +1,14 @@
+import 'server-only';
+
+// Misconfiguration, not a request problem — throwing surfaces it in Vercel's
+// logs instead of silently rejecting every cron call as unauthorized.
+export function rejectUnauthorizedCron(request: Request): Response | null {
+  if (!process.env.CRON_SECRET)
+    throw new Error('CRON_SECRET is not configured');
+
+  const authorization = request.headers.get('authorization');
+  if (authorization !== `Bearer ${process.env.CRON_SECRET}`)
+    return Response.json({ error: 'Unauthorized' }, { status: 401 });
+
+  return null;
+}
diff --git a/lib/email/manager-digests.ts b/lib/email/manager-digests.ts
new file mode 100644
index 00000000..56713055
--- /dev/null
+++ b/lib/email/manager-digests.ts
@@ -0,0 +1,93 @@
+import 'server-only';
+
+import {
+  getDailyDigestRecipients,
+  getWeeklyDigestRecipients,
+} from '@/prisma/data/digests';
+
+import { MANAGER_DIGEST_SEND_SPACING_MS } from '@/lib/constants';
+import { delay } from '@/lib/delay';
+import { sendEmail } from '@/lib/email/resend';
+import {
+  managerDailyDigestEmail,
+  managerWeeklyDigestEmail,
+} from '@/lib/email/templates';
+import { getFirstName } from '@/lib/utils';
+
+export interface DigestDispatchResult {
+  sent: number;
+  failed: number;
+  skipped: number;
+}
+
+export async function dispatchDailyManagerDigests(
+  now: Date = new Date(),
+): Promise<DigestDispatchResult> {
+  const { recipients, skipped } = await getDailyDigestRecipients(now);
+
+  let sent = 0;
+  let failed = 0;
+  for (const recipient of recipients) {
+    try {
+      const { subject, html, text } = managerDailyDigestEmail({
+        firstName: getFirstName(recipient.name),
+        day: recipient.day,
+        positions: recipient.positions,
+        total: recipient.total,
+      });
+      await sendEmail({
+        to: recipient.email,
+        subject,
+        html,
+        text,
+        template: 'manager_daily_digest',
+        userId: recipient.userId,
+      });
+      sent += 1;
+    } catch {
+      // Already recorded as an EmailLog row by sendEmail — Vercel Cron does
+      // not retry, so one bad address must not stop the rest of the run.
+      failed += 1;
+    }
+    await delay(MANAGER_DIGEST_SEND_SPACING_MS);
+  }
+
+  return { sent, failed, skipped };
+}
+
+export async function dispatchWeeklyManagerDigests(
+  now: Date = new Date(),
+): Promise<DigestDispatchResult> {
+  const { recipients, skipped } = await getWeeklyDigestRecipients(now);
+
+  let sent = 0;
+  let failed = 0;
+  for (const recipient of recipients) {
+    try {
+      const { subject, html, text } = managerWeeklyDigestEmail({
+        firstName: getFirstName(recipient.name),
+        weekStart: recipient.weekStart,
+        weekEnd: recipient.weekEnd,
+        newApplications: recipient.newApplications,
+        statusCounts: recipient.statusCounts,
+        openPositions: recipient.openPositions,
+      });
+      await sendEmail({
+        to: recipient.email,
+        subject,
+        html,
+        text,
+        template: 'manager_weekly_digest',
+        userId: recipient.userId,
+      });
+      sent += 1;
+    } catch {
+      // Already recorded as an EmailLog row by sendEmail — Vercel Cron does
+      // not retry, so one bad address must not stop the rest of the run.
+      failed += 1;
+    }
+    await delay(MANAGER_DIGEST_SEND_SPACING_MS);
+  }
+
+  return { sent, failed, skipped };
+}
diff --git a/tests/db/manager-digests.test.ts b/tests/db/manager-digests.test.ts
new file mode 100644
index 00000000..cef24389
--- /dev/null
+++ b/tests/db/manager-digests.test.ts
@@ -0,0 +1,374 @@
+import {
+  TEST_PREFIX,
+  cleanupFixtures,
+  createTestApplication,
+  createTestPosition,
+  createTestUser,
+} from '@/tests/helpers/fixtures';
+import { randomUUID } from 'node:crypto';
+import {
+  afterAll,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  it,
+  vi,
+} from 'vitest';
+
+import type { Position, User } from '@/prisma/client';
+
+import {
+  orgDayStart,
+  previousOrgDay,
+  previousOrgWeek,
+  toOrgDayString,
+} from '@/lib/dates';
+import { prisma } from '@/lib/prisma';
+
+const mockSend = vi.fn();
+
+vi.mock('resend', () => ({
+  Resend: class {
+    emails = { send: (...args: unknown[]) => mockSend(...args) };
+  },
+}));
+
+const { GET: dailyGET } =
+  await import('@/app/api/cron/manager-daily-digest/route');
+const { GET: weeklyGET } =
+  await import('@/app/api/cron/manager-weekly-digest/route');
+
+const DAILY_URL = 'http://localhost/api/cron/manager-daily-digest';
+const WEEKLY_URL = 'http://localhost/api/cron/manager-weekly-digest';
+const CRON_SECRET = 'test-cron-secret';
+
+function makeRequest(url: string, authorization?: string): Request {
+  return new Request(url, { headers: authorization ? { authorization } : {} });
+}
+
+function sentTo(
+  email: string,
+): { to: string; subject: string; html: string } | undefined {
+  return mockSend.mock.calls
+    .map(([args]) => args as { to: string; subject: string; html: string })
+    .find((args) => args.to === email);
+}
+
+let creator: User;
+
+beforeAll(async () => {
+  vi.stubEnv('RESEND_API_KEY', 'test-key');
+  vi.stubEnv('RESEND_FROM_EMAIL', 'noreply@example.com');
+  vi.stubEnv('CRON_SECRET', CRON_SECRET);
+  creator = await createTestUser({ isAdmin: true });
+});
+
+afterAll(async () => {
+  vi.unstubAllEnvs();
+  await cleanupFixtures();
+});
+
+beforeEach(() => {
+  mockSend.mockReset();
+  mockSend.mockResolvedValue({ data: { id: randomUUID() }, error: null });
+});
+
+describe('cron authorization', () => {
+  it('rejects a request with no Authorization header on both routes', async () => {
+    const dailyRes = await dailyGET(makeRequest(DAILY_URL));
+    expect(dailyRes.status).toBe(401);
+    expect(await dailyRes.json()).toEqual({ error: 'Unauthorized' });
+
+    const weeklyRes = await weeklyGET(makeRequest(WEEKLY_URL));
+    expect(weeklyRes.status).toBe(401);
+    expect(await weeklyRes.json()).toEqual({ error: 'Unauthorized' });
+
+    expect(mockSend).not.toHaveBeenCalled();
+  });
+
+  it('rejects a request with the wrong bearer token on both routes', async () => {
+    const dailyRes = await dailyGET(makeRequest(DAILY_URL, 'Bearer wrong'));
+    expect(dailyRes.status).toBe(401);
+
+    const weeklyRes = await weeklyGET(makeRequest(WEEKLY_URL, 'Bearer wrong'));
+    expect(weeklyRes.status).toBe(401);
+
+    expect(mockSend).not.toHaveBeenCalled();
+  });
+});
+
+describe('daily digest', () => {
+  let manager: User;
+  let position1: Position;
+  let position2: Position;
+
+  beforeEach(async () => {
+    manager = await createTestUser();
+    position1 = await createTestPosition(creator, { managers: [manager] });
+    position2 = await createTestPosition(creator, { managers: [manager] });
+  });
+
+  it('sends one email covering two positions submitted yesterday, logged once', async () => {
+    const yesterday = previousOrgDay(new Date());
+    const submittedAt = new Date(yesterday.start.getTime() + 60 * 60 * 1000);
+
+    const applicantA = await createTestUser();
+    const applicantB = await createTestUser();
+    await createTestApplication(applicantA, position1, { submittedAt });
+    await createTestApplication(applicantB, position1, { submittedAt });
+    await createTestApplication(applicantA, position2, { submittedAt });
+
+    const res = await dailyGET(makeRequest(DAILY_URL, `Bearer ${CRON_SECRET}`));
+    expect(res.status).toBe(200);
+
+    const call = sentTo(manager.email);
+    expect(call).toBeDefined();
+    expect(call?.subject).toBe('3 new applications across 2 positions');
+    expect(call?.html).toContain(`?positionId=${position1.id}`);
+    expect(call?.html).toContain(`?positionId=${position2.id}`);
+
+    const logs = await prisma.emailLog.findMany({
+      where: { userId: manager.id, template: 'manager_daily_digest' },
+    });
+    expect(logs).toHaveLength(1);
+    expect(logs[0]?.applicationId).toBeNull();
+  });
+
+  it('excludes submissions from today and from two days ago', async () => {
+    const now = new Date();
+    const todaySubmittedAt = new Date(
+      orgDayStart(toOrgDayString(now)).getTime() + 60 * 60 * 1000,
+    );
+    const twoDaysAgo = previousOrgDay(previousOrgDay(now).start);
+    const twoDaysAgoSubmittedAt = new Date(
+      twoDaysAgo.start.getTime() + 60 * 60 * 1000,
+    );
+
+    const applicantToday = await createTestUser();
+    const applicantTwoDaysAgo = await createTestUser();
+    await createTestApplication(applicantToday, position1, {
+      submittedAt: todaySubmittedAt,
+    });
+    await createTestApplication(applicantTwoDaysAgo, position1, {
+      submittedAt: twoDaysAgoSubmittedAt,
+    });
+
+    const res = await dailyGET(makeRequest(DAILY_URL, `Bearer ${CRON_SECRET}`));
+    expect(res.status).toBe(200);
+    expect(sentTo(manager.email)).toBeUndefined();
+
+    const logs = await prisma.emailLog.findMany({
+      where: { userId: manager.id, template: 'manager_daily_digest' },
+    });
+    expect(logs).toHaveLength(0);
+  });
+
+  it('sends nothing to a manager with no new activity', async () => {
+    const res = await dailyGET(makeRequest(DAILY_URL, `Bearer ${CRON_SECRET}`));
+    expect(res.status).toBe(200);
+    expect(sentTo(manager.email)).toBeUndefined();
+  });
+
+  it('gates a repeat call the same day after a successful send', async () => {
+    const yesterday = previousOrgDay(new Date());
+    const submittedAt = new Date(yesterday.start.getTime() + 60 * 60 * 1000);
+    const applicant = await createTestUser();
+    await createTestApplication(applicant, position1, { submittedAt });
+
+    const first = await dailyGET(
+      makeRequest(DAILY_URL, `Bearer ${CRON_SECRET}`),
+    );
+    expect(first.status).toBe(200);
+    expect(sentTo(manager.email)).toBeDefined();
+
+    mockSend.mockClear();
+
+    const second = await dailyGET(
+      makeRequest(DAILY_URL, `Bearer ${CRON_SECRET}`),
+    );
+    const body = (await second.json()) as { skipped: number };
+    expect(body.skipped).toBeGreaterThanOrEqual(1);
+    expect(sentTo(manager.email)).toBeUndefined();
+
+    const logs = await prisma.emailLog.findMany({
+      where: { userId: manager.id, template: 'manager_daily_digest' },
+    });
+    expect(logs).toHaveLength(1);
+  });
+
+  it('excludes a deactivated manager and a manager who only manages a draft position', async () => {
+    const yesterday = previousOrgDay(new Date());
+    const submittedAt = new Date(yesterday.start.getTime() + 60 * 60 * 1000);
+
+    const deactivatedManager = await createTestUser({ deletedAt: new Date() });
+    const deactivatedManagerPosition = await createTestPosition(creator, {
+      managers: [deactivatedManager],
+    });
+    const applicantA = await createTestUser();
+    await createTestApplication(applicantA, deactivatedManagerPosition, {
+      submittedAt,
+    });
+
+    const draftOnlyManager = await createTestUser();
+    const draftPosition = await createTestPosition(creator, {
+      managers: [draftOnlyManager],
+      status: 'draft',
+    });
+    const applicantB = await createTestUser();
+    await createTestApplication(applicantB, draftPosition, { submittedAt });
+
+    const res = await dailyGET(makeRequest(DAILY_URL, `Bearer ${CRON_SECRET}`));
+    expect(res.status).toBe(200);
+    expect(sentTo(deactivatedManager.email)).toBeUndefined();
+    expect(sentTo(draftOnlyManager.email)).toBeUndefined();
+  });
+});
+
+describe('weekly digest', () => {
+  let manager: User;
+  let openPosition: Position;
+  let closedByDatePosition: Position;
+
+  beforeEach(async () => {
+    manager = await createTestUser();
+    openPosition = await createTestPosition(creator, { managers: [manager] });
+    closedByDatePosition = await createTestPosition(creator, {
+      managers: [manager],
+      closesAt: new Date(Date.now() - 24 * 60 * 60 * 1000),
+    });
+  });
+
+  it('sends one email with totals, a status breakdown excluding withdrawn/draft, and open positions excluding a closed-by-date one', async () => {
+    const week = previousOrgWeek(new Date());
+    const submittedAt = new Date(week.start.getTime() + 60 * 60 * 1000);
+
+    const applicantApplied = await createTestUser();
+    const applicantReviewing = await createTestUser();
+    const applicantAccepted = await createTestUser();
+    const applicantWithdrawn = await createTestUser();
+    const applicantDraft = await createTestUser();
+
+    await createTestApplication(applicantApplied, openPosition, {
+      submittedAt,
+      status: 'applied',
+    });
+    await createTestApplication(applicantReviewing, openPosition, {
+      submittedAt,
+      status: 'reviewing',
+    });
+    await createTestApplication(applicantAccepted, closedByDatePosition, {
+      submittedAt,
+      status: 'accepted',
+    });
+    await createTestApplication(applicantWithdrawn, openPosition, {
+      submittedAt,
+      status: 'withdrawn',
+    });
+    await createTestApplication(applicantDraft, openPosition, {
+      submittedAt,
+      status: 'draft',
+    });
+
+    const res = await weeklyGET(
+      makeRequest(WEEKLY_URL, `Bearer ${CRON_SECRET}`),
+    );
+    expect(res.status).toBe(200);
+
+    const call = sentTo(manager.email);
+    expect(call).toBeDefined();
+    expect(call?.subject).toBe('Your week on Aplio: 3 new applications');
+    expect(call?.html).toContain('?status=applied');
+    expect(call?.html).toContain('?status=reviewing');
+    expect(call?.html).toContain('?status=accepted');
+    expect(call?.html).toContain(`?positionId=${openPosition.id}`);
+    expect(call?.html).not.toContain(`?positionId=${closedByDatePosition.id}`);
+
+    const logs = await prisma.emailLog.findMany({
+      where: { userId: manager.id, template: 'manager_weekly_digest' },
+    });
+    expect(logs).toHaveLength(1);
+    expect(logs[0]?.applicationId).toBeNull();
+  });
+
+  it('sends nothing with zero new applications and nothing unresolved', async () => {
+    const res = await weeklyGET(
+      makeRequest(WEEKLY_URL, `Bearer ${CRON_SECRET}`),
+    );
+    expect(res.status).toBe(200);
+    expect(sentTo(manager.email)).toBeUndefined();
+  });
+
+  it('sends the awaiting-review subject with zero new applications but something unresolved', async () => {
+    const now = new Date();
+    const twoWeeksAgo = previousOrgWeek(previousOrgWeek(now).start);
+    const submittedAt = new Date(twoWeeksAgo.start.getTime() + 60 * 60 * 1000);
+    const applicant = await createTestUser();
+    await createTestApplication(applicant, openPosition, {
+      submittedAt,
+      status: 'applied',
+    });
+
+    const res = await weeklyGET(
+      makeRequest(WEEKLY_URL, `Bearer ${CRON_SECRET}`),
+    );
+    expect(res.status).toBe(200);
+
+    const call = sentTo(manager.email);
+    expect(call).toBeDefined();
+    expect(call?.subject).toBe(
+      'Your week on Aplio: 1 application awaiting review',
+    );
+  });
+
+  it('gates a repeat call the same week', async () => {
+    const week = previousOrgWeek(new Date());
+    const submittedAt = new Date(week.start.getTime() + 60 * 60 * 1000);
+    const applicant = await createTestUser();
+    await createTestApplication(applicant, openPosition, {
+      submittedAt,
+      status: 'applied',
+    });
+
+    const first = await weeklyGET(
+      makeRequest(WEEKLY_URL, `Bearer ${CRON_SECRET}`),
+    );
+    expect(first.status).toBe(200);
+    expect(sentTo(manager.email)).toBeDefined();
+
+    mockSend.mockClear();
+
+    const second = await weeklyGET(
+      makeRequest(WEEKLY_URL, `Bearer ${CRON_SECRET}`),
+    );
+    const body = (await second.json()) as { skipped: number };
+    expect(body.skipped).toBeGreaterThanOrEqual(1);
+    expect(sentTo(manager.email)).toBeUndefined();
+  });
+
+  it('is not gated by an existing daily-digest row for the same manager', async () => {
+    const week = previousOrgWeek(new Date());
+    const submittedAt = new Date(week.start.getTime() + 60 * 60 * 1000);
+    const applicant = await createTestUser();
+    await createTestApplication(applicant, openPosition, {
+      submittedAt,
+      status: 'applied',
+    });
+
+    await prisma.emailLog.create({
+      data: {
+        to: manager.email,
+        userId: manager.id,
+        template: 'manager_daily_digest',
+        subject: `${TEST_PREFIX}unrelated daily digest`,
+        status: 'sent',
+      },
+    });
+
+    const res = await weeklyGET(
+      makeRequest(WEEKLY_URL, `Bearer ${CRON_SECRET}`),
+    );
+    expect(res.status).toBe(200);
+    expect(sentTo(manager.email)).toBeDefined();
+  });
+});
diff --git a/vercel.json b/vercel.json
index 149fcce3..f0ea9074 100644
--- a/vercel.json
+++ b/vercel.json
@@ -1,4 +1,8 @@
 {
   "$schema": "https://openapi.vercel.sh/vercel.json",
-  "buildCommand": "if [ \"$VERCEL_ENV\" = \"preview\" ]; then DATABASE_URL=\"$DATABASE_URL_UNPOOLED\" npm run prisma:migrate:deploy; fi && npm run build"
+  "buildCommand": "if [ \"$VERCEL_ENV\" = \"preview\" ]; then DATABASE_URL=\"$DATABASE_URL_UNPOOLED\" npm run prisma:migrate:deploy; fi && npm run build",
+  "crons": [
+    { "path": "/api/cron/manager-daily-digest", "schedule": "0 12 * * *" },
+    { "path": "/api/cron/manager-weekly-digest", "schedule": "0 13 * * 1" }
+  ]
 }

From eddcecccb2f7bbb6fa084a4ec4655064904804fa Mon Sep 17 00:00:00 2001
From: b-at-neu <winkler.b@northeastern.edu>
Date: Fri, 11 Sep 2026 23:48:29 -0400
Subject: [PATCH 05/35] #549 amend api-route allowlist for the digest cron
 routes

Appends both cron routes to CLAUDE.md's allowlist per #569's shape,
and updates ENGINEERING/PERMISSIONS/WORKFLOWS for the new swallow
site, the machine-authenticated route, and the two digest workflows.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 CLAUDE.md           |  1 +
 docs/ENGINEERING.md |  1 +
 docs/PERMISSIONS.md |  1 +
 docs/WORKFLOWS.md   | 17 ++++++++++++++---
 4 files changed, 17 insertions(+), 3 deletions(-)

diff --git a/CLAUDE.md b/CLAUDE.md
index 9dc9cef5..1e5446a6 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -17,6 +17,7 @@ Next.js 16 (App Router, React 19) · Prisma 7 · Tailwind CSS 4 · shadcn/ui (Ra
 - **IMPORTANT: routes under `app/api/` are forbidden except for the ones allowlisted here.** Mutations are Server Actions; a route earns a line below only when it needs something an action cannot have, and a new route is a rule change that appends to this list.
   - `app/api/auth/[...path]/route.ts` — Better Auth needs a reachable HTTP endpoint.
   - `app/api/webhooks/resend/route.ts` — Resend signs the **raw** request body, which a server action never sees.
+  - `app/api/cron/manager-daily-digest/route.ts` and `app/api/cron/manager-weekly-digest/route.ts` — Vercel Cron needs an HTTP trigger on a schedule, which a server action cannot have. **Each route runs exactly the one digest its path names — these are not a job runner; a third job needs its own route, its own line, and its own justification.**
 - **Mutations are Server Actions** in `prisma/actions/`, each with `'use server'`, an auth check, and zod validation. They return **`void` / the relevant data on success, `{ error }` for a user-facing failure, and `throw` for unexpected ones — never `{ ok }`** (`docs/ENGINEERING.md` §4). Decision test: _would you show this exact sentence to the user, and can they act on it?_ **yes → `{ error }`, no → throw**.
 - **Data fetching is server-side** — server components call data-fetching functions in `prisma/data/`; Prisma never runs in a client component. **Avoid `useEffect`** — almost every use is a mistake here, and an empty-deps `useEffect` is essentially never right.
 - **Default to server components**; add `'use client'` only for interactivity/hooks/browser APIs, on the smallest leaf possible.
diff --git a/docs/ENGINEERING.md b/docs/ENGINEERING.md
index 65ee63ef..84ad2d05 100644
--- a/docs/ENGINEERING.md
+++ b/docs/ENGINEERING.md
@@ -149,6 +149,7 @@ A thrown error reaches Vercel's runtime logs with a stack and request context; a
   - **A client `catch` that also toasts** — the §3-mandated wrapper around a server action, where the log keeps a real bug distinguishable from a stale-permission denial. Logging with **no** toast is not exempt.
   - **A server-side cause the browser can't see** (`prisma/actions/auth.ts`) — log the upstream error, return `{ error }` with safe copy.
   - **Best-effort side effects get no automatic exemption.** Where the caller can retry (a webhook whose 500 is retried), **throw** — `lib/email/resend.ts` still does, for both the single send and the batch send. The one exemption is a domain email already dispatched from `after()`: `lib/email/application-emails.ts` is the named swallow site, since the mutation it follows has already committed and the `EmailLog` row is the record that makes swallowing correct.
+  - **A second, differently-justified swallow site: `lib/email/manager-digests.ts`.** No mutation sits behind a digest send — the caller is Vercel Cron, which does not retry a 200 — so throwing on one bad address would abandon every later manager in the run rather than protect anything. Each recipient's send is its own `try`/`catch`; the `EmailLog` row is still the record.
 
 ## 5. Accessibility
 
diff --git a/docs/PERMISSIONS.md b/docs/PERMISSIONS.md
index c43a82ee..a0812f3f 100644
--- a/docs/PERMISSIONS.md
+++ b/docs/PERMISSIONS.md
@@ -44,6 +44,7 @@ Four principals, each derived rather than stored as a single role field:
 - **Draft visibility is the question two audit passes answered differently: it is visible to its managers and admins only.** `resolvePositionView` (`app/(main)/positions/[id]/page.tsx`) returns `null` — and the page calls `notFound()` — when `position.status === 'draft' && !canManage`. A manager opening a draft position's public detail page sees it; a signed-in non-manager or anonymous visitor 404s identically.
 - **The two shapes of applicant denial on the review routes are both correct, deliberately.** `/manage/applications` denies with the page guard `requireManagerOrAdminOr404` — the list itself is off-limits to a plain applicant. `/manage/applications/[id]` denies by **query scoping** (`getCurrentUser` + `buildApplicationWhere(user, 'listable')` → `notFound()`) — the detail route must 404 identically for "not yours" and "doesn't exist", so it can't gate at the top with a role check.
 - `app/(main)/(auth)/layout.tsx` is the group-level gate: `getCurrentUser()` + `requireName()`. It wraps `manage/applications`, `manage/applications/[id]`, `global-questions`, `applications`, `applications/[id]`, `positions/[id]/apply`, `manage/positions`, `manage/positions/[id]/edit`, and `users`. `/`, `/positions`, `/positions/[id]`, and `/profile` sit outside that group and self-call `requireName` on a signed-in caller.
+- **`/api/cron/manager-daily-digest` and `/api/cron/manager-weekly-digest` carry no principal.** They are machine-authenticated — `rejectUnauthorizedCron` (`lib/cron.ts`) checks a bearer secret (`CRON_SECRET`) against the request header before any DB access — not one of the four principals above, so they don't fit this table's columns.
 
 ## Server-action authorization
 
diff --git a/docs/WORKFLOWS.md b/docs/WORKFLOWS.md
index 57e4596a..f3c993c9 100644
--- a/docs/WORKFLOWS.md
+++ b/docs/WORKFLOWS.md
@@ -21,7 +21,7 @@ Behaviour shared by many workflows is stated once under [Cross-cutting behaviour
 
 ## Table of contents
 
-**[Cross-cutting behaviours](#cross-cutting-behaviours)** — [XC-1](#xc-1-sign-in-gate-and-the-redirectto-round-trip) · [XC-2](#xc-2-name-gate) · [XC-3](#xc-3-profile-completeness) · [XC-4](#xc-4-denial-shape) · [XC-5](#xc-5-errors-and-feedback) · [XC-6](#xc-6-rate-limiting) · [XC-7](#xc-7-deactivated-account) · [XC-8](#xc-8-applicant-facing-status-grouping) · [XC-9](#xc-9-applicant-email)
+**[Cross-cutting behaviours](#cross-cutting-behaviours)** — [XC-1](#xc-1-sign-in-gate-and-the-redirectto-round-trip) · [XC-2](#xc-2-name-gate) · [XC-3](#xc-3-profile-completeness) · [XC-4](#xc-4-denial-shape) · [XC-5](#xc-5-errors-and-feedback) · [XC-6](#xc-6-rate-limiting) · [XC-7](#xc-7-deactivated-account) · [XC-8](#xc-8-applicant-facing-status-grouping) · [XC-9](#xc-9-applicant-email) · [XC-10](#xc-10-manager-digests)
 
 **[Anonymous (AN)](#anonymous-an)** — [AN-1](#an-1-browse-positions) · [AN-2](#an-2-view-a-position) · [AN-3](#an-3-start-applying-from-a-position) · [AN-4](#an-4-sign-in-with-an-email-code) · [AN-5](#an-5-request-a-new-code) · [AN-6](#an-6-set-your-name-on-first-sign-in) · [AN-7](#an-7-read-the-legal-pages) · [AN-8](#an-8-dev-bypass-sign-in)
 
@@ -89,6 +89,17 @@ Three applicant-facing email _events_, over two rendered templates, all through
 - **Decision, bulk** (`updateApplicationStatuses`) — the same self-managed delay+undo as the single path, just one shared wait for the whole batch: every eligible row logs `scheduled` immediately, the wait elapses once, then only the rows still `scheduled` go out together through Resend's batch endpoint (chunked at `RESEND_BATCH_MAX_EMAILS` (100) with permissive validation so one bad address can't sink the rest), upgrading to `sent` with their own provider id. Bulk eligibility isn't forward-only, so a bulk move can land on a row that still holds a pending single-decision send; `dispatchBulkDecisionEmails` cancels it first, same as the single path — always a DB flip, never a provider call. Undo reverts **each** application to **its own individual** prior status rather than one shared target, since a batch can mix forward, backward, and final-decision rows — `updateApplicationStatuses` returns each updated row's prior status for the client to call `updateApplicationStatus` per row. Available to every reviewer who can bulk-change status at all — there is no email-specific permission gate, so a manager's bulk accept/reject emails exactly as an admin's does ([PM-12](#pm-12-move-several-applications-at-once)).
 - **One decision email ever, per application.** Once a decision email for an application has reached `sent` or later (`sent` / `delivered` / `bounced` / `complained` / `suppressed` — anything past `scheduled`), no later status change — single or bulk, any number of flips back and forth (accept → reviewing → reject → reviewing → accept, …) — schedules or sends another. The status write itself still succeeds; only the email is suppressed. This is permanent and independent of the 10-second window above.
 - **No email at all** on any in-group move (`reached_out` / `interview_scheduled` / `reviewing`) or on withdrawal — only a decision or a submission ever emails the applicant.
+
+### XC-10 Manager digests
+
+Two cron-triggered emails, both windowed by the **org calendar**, not by a per-manager "since last send" — daily and weekly are independent cadences that never gate each other.
+
+- **Daily** (`manager_daily_digest`) — `GET /api/cron/manager-daily-digest`, Vercel Cron at `0 12 * * *` UTC (08:00 ET). Covers the previous org calendar day. A manager with at least one new application on any managed position gets one email covering every such position, grouped, each linking to that position's filtered queue (`/manage/applications?positionId=<id>`); a manager with nothing new gets nothing.
+- **Weekly** (`manager_weekly_digest`) — `GET /api/cron/manager-weekly-digest`, Vercel Cron at `0 13 * * 1` UTC, Mondays. Covers the previous Monday–Sunday org week: new applications, a status breakdown (`/manage/applications?status=<value>` per row), and the manager's currently-open positions as context. Sent when there's anything new **or** anything still unresolved — an open position with zero new applications and zero unresolved is not itself a reason to send.
+- **Idempotent per period, not per send.** Neither cadence has a stored "last sent" column — both are gated by whether an `EmailLog` row for that template already exists inside the current calendar day/week (`prisma/data/digests.ts`), so a double-fire is a no-op. A manager who manages several positions always gets **one** email per cadence, never one per position.
+- **Machine-authenticated, no principal.** Both routes reject any request whose `Authorization` header isn't `Bearer ${CRON_SECRET}` before touching the database (`lib/cron.ts`) — see `PERMISSIONS.md` → "Route access".
+- **Swallowed per recipient, like [XC-9](#xc-9-applicant-email) but for a different reason.** `lib/email/manager-digests.ts` catches each manager's send individually — Vercel Cron never retries a 200, so a thrown failure would only abandon every manager after the first bad address, not protect a mutation (there isn't one behind a digest). The `EmailLog` row, `failed` included, is the record; a failed digest is not retried within its period.
+- **Not a general job runner.** Each route computes and sends exactly the one digest its path names (`CLAUDE.md`'s allowlist).
 - **A failed send never fails the mutation.** The status write (or the submission) has already committed by the time the email is attempted; the send is a side effect dispatched in `after()`, and a provider failure is logged to `EmailLog` as `failed` and surfaced nowhere — not to the reviewer, not to the applicant.
 - **No opt-out, no preferences, no per-position copy.**
 
@@ -500,7 +511,7 @@ A user who manages at least one non-deleted position. Manager status is **derive
 ### PM-9 Open an application for review
 
 - **Trigger** — a row on `/manage/applications` (`/manage/applications/[id]`).
-- **Happy path** — `getApplicationForReview(id, user)` uses the `listable` scope — withdrawn rows are kept, drafts are not — and `getApplicationStatusHistory(id, user)` fetches alongside it. The page shows a "Back to Applications" link, then a header row with the applicant's snapshotted name and status badge together, their email underneath, and a header action appropriate to status, right-aligned on that same row — a split button for the four unresolved statuses (its caret dropdown ends in **See more**, which opens the status dialog), or for terminal decisions and non-reviewable statuses alike, the same explanatory note plus a standalone caret whose dropdown menu also ends in **See more** — there is no separate standalone `⋯` for any status, since that would be a second control shape doing the same job as the caret; below it, a linked position title and the applied date, then an "Other Applications" section (`getApplicantOtherApplications`) followed by the profile and position answer groups, then an "Email History" section (`getApplicationEmailHistory`) last, each full width. The "Other Applications" section lists this applicant's other applications platform-wide — including positions the viewer doesn't manage — with precise status, applied date, and the position title linked to `/positions/[id]`; a row links to `/manage/applications/[id]` only when the viewer can actually open it (admin, or a manager of that position) — otherwise the row shows no link at all. The position-answers group lists **every** live position question, in the position's own question order, whether it was answered or not: an answered row renders from its snapshotted `questionLabel`/`value`/`type`, so a question retyped or relabeled after submission still shows the original label and value; an unanswered one shows the current question's label with "No answer" in the value slot. An answer to a since-deleted question still renders, appended after the live questions. The "Email History" section lists every `EmailLog` row for this application — subject, a status badge, and a meta line of `{Template label} · {timestamp} · {status description}` (`getEmailLogOccurredAt`) — through the same `listable` scope as the rest of the page, applied through the `application` relation; OTP rows never appear, since they're written with no `applicationId` and so can never match the equality filter (no template filter exists to be forgotten or bypassed). The template label is what tells `application_accepted` and `application_rejected` apart here, since both now render an identical subject ([XC-9](#xc-9-applicant-email)). `sent` is shown distinctly from `delivered` — a sentence under the timestamp states that delivery isn't confirmed yet, since a provider hand-off is not proof of receipt. See `PERMISSIONS.md` → "Cross-scope disclosure" for the authorization rule.
+- **Happy path** — `getApplicationForReview(id, user)` uses the `listable` scope — withdrawn rows are kept, drafts are not — and `getApplicationStatusHistory(id, user)` fetches alongside it. The page shows a "Back to Applications" link, then a header row with the applicant's snapshotted name and status badge together, their email underneath, and a header action appropriate to status, right-aligned on that same row — a split button for the four unresolved statuses (its caret dropdown ends in **See more**, which opens the status dialog), or for terminal decisions and non-reviewable statuses alike, the same explanatory note plus a standalone caret whose dropdown menu also ends in **See more** — there is no separate standalone `⋯` for any status, since that would be a second control shape doing the same job as the caret; below it, a linked position title and the applied date, then an "Other Applications" section (`getApplicantOtherApplications`) followed by the profile and position answer groups, then an "Email History" section (`getApplicationEmailHistory`) last, each full width. The "Other Applications" section lists this applicant's other applications platform-wide — including positions the viewer doesn't manage — with precise status, applied date, and the position title linked to `/positions/[id]`; a row links to `/manage/applications/[id]` only when the viewer can actually open it (admin, or a manager of that position) — otherwise the row shows no link at all. The position-answers group lists **every** live position question, in the position's own question order, whether it was answered or not: an answered row renders from its snapshotted `questionLabel`/`value`/`type`, so a question retyped or relabeled after submission still shows the original label and value; an unanswered one shows the current question's label with "No answer" in the value slot. An answer to a since-deleted question still renders, appended after the live questions. The "Email History" section lists every `EmailLog` row for this application — subject, a status badge, and a meta line of `{Template label} · {timestamp} · {status description}` (`getEmailLogOccurredAt`) — through the same `listable` scope as the rest of the page, applied through the `application` relation; OTP rows never appear, since they're written with no `applicationId` and so can never match the equality filter (no template filter exists to be forgotten or bypassed). The template label is what tells `application_accepted` and `application_rejected` apart here, since both now render an identical subject ([XC-9](#xc-9-applicant-email)). `sent` is shown distinctly from `delivered` — a sentence under the timestamp states that delivery isn't confirmed yet, since a provider hand-off is not proof of receipt. See `PERMISSIONS.md` → "Cross-scope disclosure" for the authorization rule. A manager working this queue may separately receive a daily digest of new arrivals or a weekly reminder of everything still unresolved across their positions ([XC-10](#xc-10-manager-digests)) — neither email is tied to any one application, so neither appears in this page's Email History section.
 - **Failure / edge**
   - Outside the caller's scope, a draft, or missing → `notFound()`; unauthorized and missing are indistinguishable.
   - The applicant renamed themselves since submitting → the heading reads "<snapshotted name> (<current name>)".
@@ -688,7 +699,7 @@ An admin is a **manager on every position**: every [Position manager](#position-
 ### AD-12 Look up an email
 
 - **Trigger** — `/emails`, or a failure-strip card's link (e.g. `/emails?status=bounced`).
-- **Happy path** — the page opens with a **Delivery failures** strip (bounced, complained, failed counts over the last 7 days; each card links into the matching status filter) above a **Status** / **Template** / **Search by recipient address** toolbar and a newest-first table. Search is debounced and case-insensitive over the recipient address. A bounced row shows its `bounceType` (**Permanent** vs **Transient**) alongside the status badge, plus the provider's error text. A legend line above the table reads **"Sent means Resend accepted the message — only Delivered confirms it reached the inbox. Newest first."** — `sent` never renders with the success badge variant. Pagination round-trips through the URL exactly like [`/manage/applications`](#pm-8-work-the-application-queue); a filter change lands on page 1, and a stale `?page=` clamps to the last page instead of rendering blank.
+- **Happy path** — the page opens with a **Delivery failures** strip (bounced, complained, failed counts over the last 7 days; each card links into the matching status filter) above a **Status** / **Template** / **Search by recipient address** toolbar and a newest-first table. Search is debounced and case-insensitive over the recipient address. A bounced row shows its `bounceType` (**Permanent** vs **Transient**) alongside the status badge, plus the provider's error text. A legend line above the table reads **"Sent means Resend accepted the message — only Delivered confirms it reached the inbox. Newest first."** — `sent` never renders with the success badge variant. Pagination round-trips through the URL exactly like [`/manage/applications`](#pm-8-work-the-application-queue); a filter change lands on page 1, and a stale `?page=` clamps to the last page instead of rendering blank. The **Template** filter includes `Manager daily digest` and `Manager weekly digest` ([XC-10](#xc-10-manager-digests)) alongside the applicant-facing templates; a digest row's recipient is a manager, not an applicant, and its `applicationId` is always null, so it never appears in any application's **Email history** ([PM-9](#pm-9-open-an-application-for-review)).
 - **Failure / edge**
   - A manager or applicant visiting `/emails` directly → 404, same as any other admin-only route; no **Email Log** nav entry for either.
   - No emails match the current filters → the table's "No emails match your filters." row/card; **Clear filters** resets search, status and template together.

From 3d2e4122e01fd32d125a4eabbcc2827de592e8b0 Mon Sep 17 00:00:00 2001
From: b-at-neu <winkler.b@northeastern.edu>
Date: Sat, 12 Sep 2026 00:04:12 -0400
Subject: [PATCH 06/35] #549 address review feedback

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 lib/email/templates.ts             |  4 ++++
 prisma/data/digests.ts             | 12 ++---------
 tests/db/manager-digests.test.ts   | 34 ++++++++++++++++++++++++++++++
 tests/unit/email-templates.test.ts | 11 ++++++++++
 4 files changed, 51 insertions(+), 10 deletions(-)

diff --git a/lib/email/templates.ts b/lib/email/templates.ts
index f8592b83..a9021a81 100644
--- a/lib/email/templates.ts
+++ b/lib/email/templates.ts
@@ -272,10 +272,14 @@ function formatDigestDay(day: string): string {
 }
 
 function formatDigestWeekRange(startDay: string, endDay: string): string {
+  // Only the start label carries the year conditionally — a week spanning a
+  // year boundary would otherwise read ambiguously (Dec 29 – Jan 4, 2027).
+  const crossesYear = startDay.slice(0, 4) !== endDay.slice(0, 4);
   const startLabel = new Intl.DateTimeFormat('en-US', {
     timeZone: ORG_TIMEZONE,
     month: 'short',
     day: 'numeric',
+    ...(crossesYear ? { year: 'numeric' } : {}),
   }).format(orgDayStart(startDay));
   const endLabel = new Intl.DateTimeFormat('en-US', {
     timeZone: ORG_TIMEZONE,
diff --git a/prisma/data/digests.ts b/prisma/data/digests.ts
index 43fde2c9..ea6e2106 100644
--- a/prisma/data/digests.ts
+++ b/prisma/data/digests.ts
@@ -110,11 +110,7 @@ async function tallyStatusBreakdown(
   return map;
 }
 
-/**
- * Managers with at least one new application on a managed position over the
- * previous org calendar day, gated so a manager already digested today is
- * dropped (and counted in `skipped`) rather than emailed twice.
- */
+/** Managers with new applications yesterday, minus any already digested today (counted in `skipped`). */
 export async function getDailyDigestRecipients(
   now: Date = new Date(),
 ): Promise<{ recipients: DailyDigestRecipient[]; skipped: number }> {
@@ -175,11 +171,7 @@ export async function getDailyDigestRecipients(
   return { recipients, skipped: gatedIds.size };
 }
 
-/**
- * Managers with new applications or anything unresolved on a managed
- * position over the previous org Monday-Sunday week. Same per-period gate
- * shape as the daily digest, keyed to `manager_weekly_digest` rows.
- */
+/** Managers with new or unresolved applications last week, gated like the daily digest. */
 export async function getWeeklyDigestRecipients(
   now: Date = new Date(),
 ): Promise<{ recipients: WeeklyDigestRecipient[]; skipped: number }> {
diff --git a/tests/db/manager-digests.test.ts b/tests/db/manager-digests.test.ts
index cef24389..156a4bb4 100644
--- a/tests/db/manager-digests.test.ts
+++ b/tests/db/manager-digests.test.ts
@@ -197,6 +197,40 @@ describe('daily digest', () => {
     expect(logs).toHaveLength(1);
   });
 
+  it('does not stop the run when one recipient send fails, and records it as failed', async () => {
+    const yesterday = previousOrgDay(new Date());
+    const submittedAt = new Date(yesterday.start.getTime() + 60 * 60 * 1000);
+
+    const applicant = await createTestUser();
+    await createTestApplication(applicant, position1, { submittedAt });
+
+    const managerOk = await createTestUser();
+    const positionOk = await createTestPosition(creator, {
+      managers: [managerOk],
+    });
+    const applicantOk = await createTestUser();
+    await createTestApplication(applicantOk, positionOk, { submittedAt });
+
+    mockSend.mockImplementation(async (args: { to: string }) => {
+      if (args.to === manager.email) throw new Error('simulated send failure');
+      return { data: { id: randomUUID() }, error: null };
+    });
+
+    const res = await dailyGET(makeRequest(DAILY_URL, `Bearer ${CRON_SECRET}`));
+    const body = (await res.json()) as { sent: number; failed: number };
+    expect(body.failed).toBeGreaterThanOrEqual(1);
+    expect(sentTo(managerOk.email)).toBeDefined();
+
+    const failedLogs = await prisma.emailLog.findMany({
+      where: {
+        userId: manager.id,
+        template: 'manager_daily_digest',
+        status: 'failed',
+      },
+    });
+    expect(failedLogs).toHaveLength(1);
+  });
+
   it('excludes a deactivated manager and a manager who only manages a draft position', async () => {
     const yesterday = previousOrgDay(new Date());
     const submittedAt = new Date(yesterday.start.getTime() + 60 * 60 * 1000);
diff --git a/tests/unit/email-templates.test.ts b/tests/unit/email-templates.test.ts
index d613002b..06c46a33 100644
--- a/tests/unit/email-templates.test.ts
+++ b/tests/unit/email-templates.test.ts
@@ -350,4 +350,15 @@ describe('managerWeeklyDigestEmail', () => {
     expect(result.html).toContain('Mar 8, 2026');
     expect(result.html).toContain(MANAGER_EMAIL_FOOTER);
   });
+
+  it('disambiguates a week range that crosses a year boundary', () => {
+    const result = managerWeeklyDigestEmail({
+      weekStart: '2026-12-28',
+      weekEnd: '2027-01-03',
+      openPositions: [],
+      newApplications: 4,
+      statusCounts: [],
+    });
+    expect(result.html).toContain('Dec 28, 2026 – Jan 3, 2027');
+  });
 });

From 7054cb70fbc22ec3e0cf8c9483e8f7be663cf80a Mon Sep 17 00:00:00 2001
From: b-at-neu <winkler.b@northeastern.edu>
Date: Sat, 12 Sep 2026 00:13:32 -0400
Subject: [PATCH 07/35] #549 address review feedback

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 lib/email/templates.ts             | 14 +++++++++-----
 tests/unit/email-templates.test.ts | 15 +++++++++++++++
 2 files changed, 24 insertions(+), 5 deletions(-)

diff --git a/lib/email/templates.ts b/lib/email/templates.ts
index a9021a81..5638532b 100644
--- a/lib/email/templates.ts
+++ b/lib/email/templates.ts
@@ -1,7 +1,11 @@
 import 'server-only';
 
 import { getBaseUrl } from '@/lib/base-url';
-import { APPLICATION_STATUS_LABELS, ORG_TIMEZONE } from '@/lib/constants';
+import {
+  APPLICATION_STATUS_LABELS,
+  ORG_TIMEZONE,
+  UNRESOLVED_APPLICATION_STATUSES,
+} from '@/lib/constants';
 import { orgDayStart } from '@/lib/dates';
 import {
   type ManagerDigestPosition,
@@ -372,10 +376,10 @@ export function managerWeeklyDigestEmail({
   const allApplicationsUrl = `${baseUrl}/manage/applications`;
   const weekRangeLabel = formatDigestWeekRange(weekStart, weekEnd);
   const safeGreeting = escapeHtml(greeting(firstName));
-  const unresolvedTotal = statusCounts.reduce(
-    (sum, entry) => sum + entry.count,
-    0,
-  );
+  const unresolvedStatuses: readonly string[] = UNRESOLVED_APPLICATION_STATUSES;
+  const unresolvedTotal = statusCounts
+    .filter((entry) => unresolvedStatuses.includes(entry.status))
+    .reduce((sum, entry) => sum + entry.count, 0);
 
   const subject =
     newApplications > 0
diff --git a/tests/unit/email-templates.test.ts b/tests/unit/email-templates.test.ts
index 06c46a33..c51db81e 100644
--- a/tests/unit/email-templates.test.ts
+++ b/tests/unit/email-templates.test.ts
@@ -294,6 +294,21 @@ describe('managerWeeklyDigestEmail', () => {
     );
   });
 
+  it('excludes terminal decisions from the awaiting-review count', () => {
+    const result = managerWeeklyDigestEmail({
+      ...base,
+      newApplications: 0,
+      statusCounts: [
+        { status: 'applied', count: 7 },
+        { status: 'accepted', count: 3 },
+        { status: 'rejected', count: 2 },
+      ],
+    });
+    expect(result.subject).toBe(
+      'Your week on Aplio: 7 applications awaiting review',
+    );
+  });
+
   it('omits zero-count statuses and links each remaining status', () => {
     const result = managerWeeklyDigestEmail({
       ...base,

From c594d25f27d115323afd39563ee6f5c89a048c88 Mon Sep 17 00:00:00 2001
From: b-at-neu <winkler.b@northeastern.edu>
Date: Sat, 12 Sep 2026 11:09:30 -0400
Subject: [PATCH 08/35] #549 make the weekly digest a pure unresolved-work
 reminder
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The weekly email no longer tallies "new applications this week" — a
manager gets it only when they have applications still short of a
terminal status, with a status-count box per status (color-coded like
the in-app badges) instead of a text recap. previousOrgWeek has no
remaining caller and is removed along with it.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 docs/WORKFLOWS.md                  |   4 +-
 lib/dates.ts                       |  17 ----
 lib/email/manager-digests.ts       |   4 +-
 lib/email/templates.ts             | 144 ++++++++++++++---------------
 lib/types.ts                       |   5 +-
 prisma/data/digests.ts             |  38 +++-----
 tests/db/manager-digests.test.ts   |  54 ++++-------
 tests/unit/dates.test.ts           |  25 -----
 tests/unit/email-templates.test.ts |  95 +++++--------------
 9 files changed, 126 insertions(+), 260 deletions(-)

diff --git a/docs/WORKFLOWS.md b/docs/WORKFLOWS.md
index f3c993c9..0ff22b45 100644
--- a/docs/WORKFLOWS.md
+++ b/docs/WORKFLOWS.md
@@ -92,10 +92,10 @@ Three applicant-facing email _events_, over two rendered templates, all through
 
 ### XC-10 Manager digests
 
-Two cron-triggered emails, both windowed by the **org calendar**, not by a per-manager "since last send" — daily and weekly are independent cadences that never gate each other.
+Two cron-triggered emails on independent cadences that never gate each other, both gated per period by an `EmailLog` row rather than a per-manager "since last send."
 
 - **Daily** (`manager_daily_digest`) — `GET /api/cron/manager-daily-digest`, Vercel Cron at `0 12 * * *` UTC (08:00 ET). Covers the previous org calendar day. A manager with at least one new application on any managed position gets one email covering every such position, grouped, each linking to that position's filtered queue (`/manage/applications?positionId=<id>`); a manager with nothing new gets nothing.
-- **Weekly** (`manager_weekly_digest`) — `GET /api/cron/manager-weekly-digest`, Vercel Cron at `0 13 * * 1` UTC, Mondays. Covers the previous Monday–Sunday org week: new applications, a status breakdown (`/manage/applications?status=<value>` per row), and the manager's currently-open positions as context. Sent when there's anything new **or** anything still unresolved — an open position with zero new applications and zero unresolved is not itself a reason to send.
+- **Weekly** (`manager_weekly_digest`) — `GET /api/cron/manager-weekly-digest`, Vercel Cron at `0 13 * * 1` UTC, Mondays. A reminder, not a recap: it has no time window on its own, and reports **every application still short of a terminal status** (not `accepted`/`rejected`/`withdrawn`/`draft`) across the manager's positions, however long it's been sitting there — a status count box per unresolved status (`/manage/applications?status=<value>`), plus the manager's currently-open positions as context. Sent only when that total is greater than zero; a manager with nothing outstanding gets nothing, regardless of how much happened that week.
 - **Idempotent per period, not per send.** Neither cadence has a stored "last sent" column — both are gated by whether an `EmailLog` row for that template already exists inside the current calendar day/week (`prisma/data/digests.ts`), so a double-fire is a no-op. A manager who manages several positions always gets **one** email per cadence, never one per position.
 - **Machine-authenticated, no principal.** Both routes reject any request whose `Authorization` header isn't `Bearer ${CRON_SECRET}` before touching the database (`lib/cron.ts`) — see `PERMISSIONS.md` → "Route access".
 - **Swallowed per recipient, like [XC-9](#xc-9-applicant-email) but for a different reason.** `lib/email/manager-digests.ts` catches each manager's send individually — Vercel Cron never retries a 200, so a thrown failure would only abandon every manager after the first bad address, not protect a mutation (there isn't one behind a digest). The `EmailLog` row, `failed` included, is the record; a failed digest is not retried within its period.
diff --git a/lib/dates.ts b/lib/dates.ts
index 75b460cd..96775d53 100644
--- a/lib/dates.ts
+++ b/lib/dates.ts
@@ -104,23 +104,6 @@ export function currentOrgWeekStart(now: Date): string {
   return shiftOrgDay(day, -daysSinceMonday);
 }
 
-/** The Monday–Sunday org week before `now`'s current week, with its instant bounds. */
-export function previousOrgWeek(now: Date): {
-  startDay: string;
-  endDay: string;
-  start: Date;
-  end: Date;
-} {
-  const startDay = shiftOrgDay(currentOrgWeekStart(now), -7);
-  const endDay = shiftOrgDay(startDay, 6);
-  return {
-    startDay,
-    endDay,
-    start: orgDayStart(startDay),
-    end: orgDayEnd(endDay),
-  };
-}
-
 export function formatInstant(
   date: Date,
   { precision, timeZone }: { precision: DatePrecision; timeZone: string },
diff --git a/lib/email/manager-digests.ts b/lib/email/manager-digests.ts
index 56713055..d4f9a080 100644
--- a/lib/email/manager-digests.ts
+++ b/lib/email/manager-digests.ts
@@ -66,9 +66,7 @@ export async function dispatchWeeklyManagerDigests(
     try {
       const { subject, html, text } = managerWeeklyDigestEmail({
         firstName: getFirstName(recipient.name),
-        weekStart: recipient.weekStart,
-        weekEnd: recipient.weekEnd,
-        newApplications: recipient.newApplications,
+        asOfDay: recipient.asOfDay,
         statusCounts: recipient.statusCounts,
         openPositions: recipient.openPositions,
       });
diff --git a/lib/email/templates.ts b/lib/email/templates.ts
index 5638532b..d0de1c1a 100644
--- a/lib/email/templates.ts
+++ b/lib/email/templates.ts
@@ -1,11 +1,9 @@
 import 'server-only';
 
+import { type $Enums } from '@/prisma/client';
+
 import { getBaseUrl } from '@/lib/base-url';
-import {
-  APPLICATION_STATUS_LABELS,
-  ORG_TIMEZONE,
-  UNRESOLVED_APPLICATION_STATUSES,
-} from '@/lib/constants';
+import { APPLICATION_STATUS_LABELS, ORG_TIMEZONE } from '@/lib/constants';
 import { orgDayStart } from '@/lib/dates';
 import {
   type ManagerDigestPosition,
@@ -275,25 +273,6 @@ function formatDigestDay(day: string): string {
   }).format(orgDayStart(day));
 }
 
-function formatDigestWeekRange(startDay: string, endDay: string): string {
-  // Only the start label carries the year conditionally — a week spanning a
-  // year boundary would otherwise read ambiguously (Dec 29 – Jan 4, 2027).
-  const crossesYear = startDay.slice(0, 4) !== endDay.slice(0, 4);
-  const startLabel = new Intl.DateTimeFormat('en-US', {
-    timeZone: ORG_TIMEZONE,
-    month: 'short',
-    day: 'numeric',
-    ...(crossesYear ? { year: 'numeric' } : {}),
-  }).format(orgDayStart(startDay));
-  const endLabel = new Intl.DateTimeFormat('en-US', {
-    timeZone: ORG_TIMEZONE,
-    month: 'short',
-    day: 'numeric',
-    year: 'numeric',
-  }).format(orgDayStart(endDay));
-  return `${startLabel} – ${endLabel}`;
-}
-
 export interface ManagerDailyDigestEmailOptions {
   firstName?: string;
   day: string;
@@ -355,51 +334,83 @@ export function managerDailyDigestEmail({
   };
 }
 
+// Only the two variants an unresolved status can carry (see
+// APPLICATION_STATUS_BADGE_VARIANT) — reviewing is the sole 'warning', the
+// rest are 'info'. Matches the in-app status-dot palette (app/globals.css).
+const DIGEST_STATUS_DOT_COLOR: Partial<
+  Record<$Enums.ApplicationStatus, string>
+> = {
+  applied: '#2563eb',
+  reached_out: '#2563eb',
+  interview_scheduled: '#2563eb',
+  reviewing: '#d97706',
+};
+
+// A single stat box: dot + big number + label, linking to the filtered queue.
+// Table-based, not flex/grid — Outlook's Word engine only renders tables reliably.
+function statBox(
+  url: string,
+  color: string,
+  count: number,
+  label: string,
+): string {
+  const safeUrl = escapeHtml(url);
+  return `<td width="50%" style="padding:4px;">
+      <a href="${safeUrl}" style="display:block;text-decoration:none;background-color:#f4f4f5;border-radius:8px;padding:16px;text-align:center;">
+        <span style="display:inline-block;width:8px;height:8px;border-radius:50%;background-color:${color};margin-bottom:6px;"></span><br />
+        <span style="display:block;font-size:24px;font-weight:700;color:#09090b;line-height:1.2;">${count}</span>
+        <span style="display:block;font-size:12px;color:#71717a;margin-top:2px;">${escapeHtml(label)}</span>
+      </a>
+    </td>`;
+}
+
+// Two boxes per row (UNRESOLVED_APPLICATION_STATUSES never exceeds four), a
+// blank spacer cell keeps the last row's alignment when the count is odd.
+function statBoxGrid(
+  entries: { url: string; color: string; count: number; label: string }[],
+): string {
+  const rows: string[] = [];
+  for (let i = 0; i < entries.length; i += 2) {
+    const a = entries[i]!;
+    const b = entries[i + 1];
+    rows.push(
+      `<tr>${statBox(a.url, a.color, a.count, a.label)}${b ? statBox(b.url, b.color, b.count, b.label) : '<td width="50%">&nbsp;</td>'}</tr>`,
+    );
+  }
+  return `<table role="presentation" width="100%" cellpadding="0" cellspacing="0" style="margin:0 0 24px;">${rows.join('')}</table>`;
+}
+
 export interface ManagerWeeklyDigestEmailOptions {
   firstName?: string;
-  weekStart: string;
-  weekEnd: string;
-  newApplications: number;
+  asOfDay: string;
   statusCounts: WeeklyDigestStatusCount[];
   openPositions: Pick<ManagerDigestPosition, 'positionId' | 'title'>[];
 }
 
+// statusCounts is always unresolved-only (WeeklyDigestRecipient's contract) —
+// this is a reminder of outstanding review work, never a terminal-decision recap.
 export function managerWeeklyDigestEmail({
   firstName,
-  weekStart,
-  weekEnd,
-  newApplications,
+  asOfDay,
   statusCounts,
   openPositions,
 }: ManagerWeeklyDigestEmailOptions): EmailTemplate {
   const baseUrl = getBaseUrl();
   const allApplicationsUrl = `${baseUrl}/manage/applications`;
-  const weekRangeLabel = formatDigestWeekRange(weekStart, weekEnd);
+  const asOfLabel = formatDigestDay(asOfDay);
   const safeGreeting = escapeHtml(greeting(firstName));
-  const unresolvedStatuses: readonly string[] = UNRESOLVED_APPLICATION_STATUSES;
-  const unresolvedTotal = statusCounts
-    .filter((entry) => unresolvedStatuses.includes(entry.status))
-    .reduce((sum, entry) => sum + entry.count, 0);
+  const total = statusCounts.reduce((sum, entry) => sum + entry.count, 0);
 
-  const subject =
-    newApplications > 0
-      ? `Your week on Aplio: ${newApplications} new ${pluralize(newApplications, 'application')}`
-      : `Your week on Aplio: ${unresolvedTotal} ${pluralize(unresolvedTotal, 'application')} awaiting review`;
-
-  const newThisWeekLine =
-    newApplications > 0
-      ? `${newApplications} new ${pluralize(newApplications, 'application')} across the positions you manage.`
-      : 'No new applications this week.';
-
-  const statusRows =
-    statusCounts.length > 0
-      ? statusCounts
-          .map((entry) => {
-            const url = `${allApplicationsUrl}?status=${entry.status}`;
-            return `<a href="${escapeHtml(url)}" style="color:#D41B2C;text-decoration:none;font-weight:600;">${escapeHtml(APPLICATION_STATUS_LABELS[entry.status])}</a> — ${entry.count}`;
-          })
-          .join('<br />')
-      : 'No applications on your positions yet.';
+  const subject = `${total} ${pluralize(total, 'application')} awaiting your review`;
+
+  const statBoxesHtml = statBoxGrid(
+    statusCounts.map((entry) => ({
+      url: `${allApplicationsUrl}?status=${entry.status}`,
+      color: DIGEST_STATUS_DOT_COLOR[entry.status] ?? '#71717a',
+      count: entry.count,
+      label: APPLICATION_STATUS_LABELS[entry.status],
+    })),
+  );
 
   const openPositionsLine =
     openPositions.length > 0
@@ -413,11 +424,8 @@ export function managerWeeklyDigestEmail({
 
   const content = `
     <p style="margin:0 0 16px;font-size:14px;color:#09090b;">${safeGreeting}</p>
-    <p style="margin:0 0 16px;font-size:14px;color:#71717a;">Your weekly summary for <strong>${escapeHtml(weekRangeLabel)}</strong>.</p>
-    <p style="margin:0 0 4px;font-size:14px;font-weight:700;color:#09090b;">New this week</p>
-    <p style="margin:0 0 16px;font-size:14px;color:#71717a;">${escapeHtml(newThisWeekLine)}</p>
-    <p style="margin:0 0 4px;font-size:14px;font-weight:700;color:#09090b;">Where things stand</p>
-    <p style="margin:0 0 16px;font-size:14px;color:#71717a;">${statusRows}</p>
+    <p style="margin:0 0 20px;font-size:14px;color:#71717a;">As of <strong>${escapeHtml(asOfLabel)}</strong>, you have ${total} ${pluralize(total, 'application')} awaiting review across the positions you manage.</p>
+    ${statBoxesHtml}
     <p style="margin:0 0 4px;font-size:14px;font-weight:700;color:#09090b;">Your open positions</p>
     <p style="margin:0 0 24px;font-size:14px;color:#71717a;">${openPositionsLine}</p>
     ${primaryButton(allApplicationsUrl, 'Review all applications')}
@@ -426,20 +434,12 @@ export function managerWeeklyDigestEmail({
   const text = [
     greeting(firstName),
     '',
-    `Your weekly summary for ${weekRangeLabel}.`,
-    '',
-    'New this week',
-    newThisWeekLine,
+    `As of ${asOfLabel}, you have ${total} ${pluralize(total, 'application')} awaiting review across the positions you manage.`,
     '',
-    'Where things stand',
-    statusCounts.length > 0
-      ? statusCounts
-          .map(
-            (entry) =>
-              `${APPLICATION_STATUS_LABELS[entry.status]} (${allApplicationsUrl}?status=${entry.status}) — ${entry.count}`,
-          )
-          .join('\n')
-      : 'No applications on your positions yet.',
+    ...statusCounts.map(
+      (entry) =>
+        `${APPLICATION_STATUS_LABELS[entry.status]}: ${entry.count} — ${allApplicationsUrl}?status=${entry.status}`,
+    ),
     '',
     'Your open positions',
     openPositions.length > 0
diff --git a/lib/types.ts b/lib/types.ts
index c375b33e..376859d2 100644
--- a/lib/types.ts
+++ b/lib/types.ts
@@ -543,6 +543,7 @@ export type DailyDigestRecipient = {
   total: number;
 };
 
+// status is always one of UNRESOLVED_APPLICATION_STATUSES — never a terminal decision.
 export type WeeklyDigestStatusCount = {
   status: $Enums.ApplicationStatus;
   count: number;
@@ -552,9 +553,7 @@ export type WeeklyDigestRecipient = {
   userId: string;
   email: string;
   name: string | null;
-  weekStart: string;
-  weekEnd: string;
-  newApplications: number;
+  asOfDay: string;
   statusCounts: WeeklyDigestStatusCount[];
   openPositions: Pick<ManagerDigestPosition, 'positionId' | 'title'>[];
 };
diff --git a/prisma/data/digests.ts b/prisma/data/digests.ts
index ea6e2106..caf69e28 100644
--- a/prisma/data/digests.ts
+++ b/prisma/data/digests.ts
@@ -5,14 +5,12 @@ import { type $Enums } from '@/prisma/client';
 import {
   NON_REVIEWABLE_APPLICATION_STATUSES,
   PUBLISHED_POSITION_WHERE,
-  REVIEWER_APPLICATION_STATUSES,
   UNRESOLVED_APPLICATION_STATUSES,
 } from '@/lib/constants';
 import {
   currentOrgWeekStart,
   orgDayStart,
   previousOrgDay,
-  previousOrgWeek,
   toOrgDayString,
 } from '@/lib/dates';
 import { prisma } from '@/lib/prisma';
@@ -86,6 +84,7 @@ async function tallyNewApplications(
 
 async function tallyStatusBreakdown(
   positionIds: string[],
+  statuses: readonly $Enums.ApplicationStatus[],
 ): Promise<Map<string, Map<$Enums.ApplicationStatus, number>>> {
   const map = new Map<string, Map<$Enums.ApplicationStatus, number>>();
   if (positionIds.length === 0) return map;
@@ -95,7 +94,7 @@ async function tallyStatusBreakdown(
     where: {
       positionId: { in: positionIds },
       deletedAt: null,
-      status: { notIn: NON_REVIEWABLE_APPLICATION_STATUSES },
+      status: { in: [...statuses] },
       position: PUBLISHED_POSITION_WHERE,
     },
     _count: true,
@@ -171,7 +170,7 @@ export async function getDailyDigestRecipients(
   return { recipients, skipped: gatedIds.size };
 }
 
-/** Managers with new or unresolved applications last week, gated like the daily digest. */
+/** Managers with any application still short of a terminal status, gated per org week. */
 export async function getWeeklyDigestRecipients(
   now: Date = new Date(),
 ): Promise<{ recipients: WeeklyDigestRecipient[]; skipped: number }> {
@@ -179,7 +178,6 @@ export async function getWeeklyDigestRecipients(
   if (managers.length === 0) return { recipients: [], skipped: 0 };
 
   const managerIds = managers.map((manager) => manager.id);
-  const { startDay, endDay, start, end } = previousOrgWeek(now);
 
   const alreadyDigested = await prisma.emailLog.findMany({
     where: {
@@ -200,14 +198,10 @@ export async function getWeeklyDigestRecipients(
   const positionIds = candidates.flatMap((manager) =>
     manager.managedPositions.map((position) => position.id),
   );
-
-  const [newTallies, statusTallies] = await Promise.all([
-    tallyNewApplications(positionIds, start, end),
-    tallyStatusBreakdown(positionIds),
-  ]);
-
-  const unresolvedStatuses: readonly $Enums.ApplicationStatus[] =
-    UNRESOLVED_APPLICATION_STATUSES;
+  const statusTallies = await tallyStatusBreakdown(
+    positionIds,
+    UNRESOLVED_APPLICATION_STATUSES,
+  );
 
   const recipients: WeeklyDigestRecipient[] = [];
   for (const manager of candidates) {
@@ -215,12 +209,7 @@ export async function getWeeklyDigestRecipients(
       (position) => position.id,
     );
 
-    const newApplications = managerPositionIds.reduce(
-      (sum, id) => sum + (newTallies.get(id) ?? 0),
-      0,
-    );
-
-    const statusCounts = REVIEWER_APPLICATION_STATUSES.map((status) => ({
+    const statusCounts = UNRESOLVED_APPLICATION_STATUSES.map((status) => ({
       status,
       count: managerPositionIds.reduce(
         (sum, id) => sum + (statusTallies.get(id)?.get(status) ?? 0),
@@ -228,11 +217,8 @@ export async function getWeeklyDigestRecipients(
       ),
     })).filter((entry) => entry.count > 0);
 
-    const unresolvedTotal = statusCounts
-      .filter((entry) => unresolvedStatuses.includes(entry.status))
-      .reduce((sum, entry) => sum + entry.count, 0);
-
-    if (newApplications === 0 && unresolvedTotal === 0) continue;
+    const total = statusCounts.reduce((sum, entry) => sum + entry.count, 0);
+    if (total === 0) continue;
 
     const openPositions = manager.managedPositions
       .filter((position) => isAcceptingApplications(position))
@@ -243,9 +229,7 @@ export async function getWeeklyDigestRecipients(
       userId: manager.id,
       email: manager.email,
       name: manager.name,
-      weekStart: startDay,
-      weekEnd: endDay,
-      newApplications,
+      asOfDay: toOrgDayString(now),
       statusCounts,
       openPositions,
     });
diff --git a/tests/db/manager-digests.test.ts b/tests/db/manager-digests.test.ts
index 156a4bb4..c23e2cdc 100644
--- a/tests/db/manager-digests.test.ts
+++ b/tests/db/manager-digests.test.ts
@@ -18,12 +18,7 @@ import {
 
 import type { Position, User } from '@/prisma/client';
 
-import {
-  orgDayStart,
-  previousOrgDay,
-  previousOrgWeek,
-  toOrgDayString,
-} from '@/lib/dates';
+import { orgDayStart, previousOrgDay, toOrgDayString } from '@/lib/dates';
 import { prisma } from '@/lib/prisma';
 
 const mockSend = vi.fn();
@@ -273,10 +268,7 @@ describe('weekly digest', () => {
     });
   });
 
-  it('sends one email with totals, a status breakdown excluding withdrawn/draft, and open positions excluding a closed-by-date one', async () => {
-    const week = previousOrgWeek(new Date());
-    const submittedAt = new Date(week.start.getTime() + 60 * 60 * 1000);
-
+  it('sends one email with a status breakdown excluding terminal/withdrawn/draft, and open positions excluding a closed-by-date one', async () => {
     const applicantApplied = await createTestUser();
     const applicantReviewing = await createTestUser();
     const applicantAccepted = await createTestUser();
@@ -284,23 +276,18 @@ describe('weekly digest', () => {
     const applicantDraft = await createTestUser();
 
     await createTestApplication(applicantApplied, openPosition, {
-      submittedAt,
       status: 'applied',
     });
     await createTestApplication(applicantReviewing, openPosition, {
-      submittedAt,
       status: 'reviewing',
     });
     await createTestApplication(applicantAccepted, closedByDatePosition, {
-      submittedAt,
       status: 'accepted',
     });
     await createTestApplication(applicantWithdrawn, openPosition, {
-      submittedAt,
       status: 'withdrawn',
     });
     await createTestApplication(applicantDraft, openPosition, {
-      submittedAt,
       status: 'draft',
     });
 
@@ -311,10 +298,10 @@ describe('weekly digest', () => {
 
     const call = sentTo(manager.email);
     expect(call).toBeDefined();
-    expect(call?.subject).toBe('Your week on Aplio: 3 new applications');
+    expect(call?.subject).toBe('2 applications awaiting your review');
     expect(call?.html).toContain('?status=applied');
     expect(call?.html).toContain('?status=reviewing');
-    expect(call?.html).toContain('?status=accepted');
+    expect(call?.html).not.toContain('?status=accepted');
     expect(call?.html).toContain(`?positionId=${openPosition.id}`);
     expect(call?.html).not.toContain(`?positionId=${closedByDatePosition.id}`);
 
@@ -325,7 +312,12 @@ describe('weekly digest', () => {
     expect(logs[0]?.applicationId).toBeNull();
   });
 
-  it('sends nothing with zero new applications and nothing unresolved', async () => {
+  it('sends nothing when there is nothing unresolved', async () => {
+    const applicant = await createTestUser();
+    await createTestApplication(applicant, openPosition, {
+      status: 'accepted',
+    });
+
     const res = await weeklyGET(
       makeRequest(WEEKLY_URL, `Bearer ${CRON_SECRET}`),
     );
@@ -333,13 +325,11 @@ describe('weekly digest', () => {
     expect(sentTo(manager.email)).toBeUndefined();
   });
 
-  it('sends the awaiting-review subject with zero new applications but something unresolved', async () => {
-    const now = new Date();
-    const twoWeeksAgo = previousOrgWeek(previousOrgWeek(now).start);
-    const submittedAt = new Date(twoWeeksAgo.start.getTime() + 60 * 60 * 1000);
+  it('sends the reminder regardless of how long an application has been unresolved', async () => {
     const applicant = await createTestUser();
+    const longAgo = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000);
     await createTestApplication(applicant, openPosition, {
-      submittedAt,
+      submittedAt: longAgo,
       status: 'applied',
     });
 
@@ -350,19 +340,12 @@ describe('weekly digest', () => {
 
     const call = sentTo(manager.email);
     expect(call).toBeDefined();
-    expect(call?.subject).toBe(
-      'Your week on Aplio: 1 application awaiting review',
-    );
+    expect(call?.subject).toBe('1 application awaiting your review');
   });
 
   it('gates a repeat call the same week', async () => {
-    const week = previousOrgWeek(new Date());
-    const submittedAt = new Date(week.start.getTime() + 60 * 60 * 1000);
     const applicant = await createTestUser();
-    await createTestApplication(applicant, openPosition, {
-      submittedAt,
-      status: 'applied',
-    });
+    await createTestApplication(applicant, openPosition, { status: 'applied' });
 
     const first = await weeklyGET(
       makeRequest(WEEKLY_URL, `Bearer ${CRON_SECRET}`),
@@ -381,13 +364,8 @@ describe('weekly digest', () => {
   });
 
   it('is not gated by an existing daily-digest row for the same manager', async () => {
-    const week = previousOrgWeek(new Date());
-    const submittedAt = new Date(week.start.getTime() + 60 * 60 * 1000);
     const applicant = await createTestUser();
-    await createTestApplication(applicant, openPosition, {
-      submittedAt,
-      status: 'applied',
-    });
+    await createTestApplication(applicant, openPosition, { status: 'applied' });
 
     await prisma.emailLog.create({
       data: {
diff --git a/tests/unit/dates.test.ts b/tests/unit/dates.test.ts
index 9f90eb66..6940cee1 100644
--- a/tests/unit/dates.test.ts
+++ b/tests/unit/dates.test.ts
@@ -7,7 +7,6 @@ import {
   orgDayEnd,
   orgDayStart,
   previousOrgDay,
-  previousOrgWeek,
   toOrgDayString,
 } from '@/lib/dates';
 
@@ -119,30 +118,6 @@ describe('currentOrgWeekStart', () => {
   });
 });
 
-describe('previousOrgWeek', () => {
-  it('spans a full Monday-Sunday week before the current one', () => {
-    const week = previousOrgWeek(noonOn('2026-03-23'));
-    expect(week.startDay).toBe('2026-03-16');
-    expect(week.endDay).toBe('2026-03-22');
-    expect(week.start).toEqual(orgDayStart('2026-03-16'));
-    expect(week.end).toEqual(orgDayEnd('2026-03-22'));
-  });
-
-  it('still spans exactly 7 calendar days across a DST change', () => {
-    // now's current week is 2026-03-09..15, so the previous week is
-    // 2026-03-02..08 — the Sunday it ends on is the spring-forward day.
-    const week = previousOrgWeek(noonOn('2026-03-09'));
-    expect(week.startDay).toBe('2026-03-02');
-    expect(week.endDay).toBe('2026-03-08');
-
-    // Spring-forward inside the week loses an hour, so the instant span is
-    // 167 hours, not 168 — the calendar-day count is still exactly 7.
-    const hours =
-      (week.end.getTime() - week.start.getTime() + 1) / (1000 * 60 * 60);
-    expect(hours).toBeCloseTo(167, 5);
-  });
-});
-
 describe('formatInstant', () => {
   const date = new Date('2026-06-30T23:30:00.000Z');
 
diff --git a/tests/unit/email-templates.test.ts b/tests/unit/email-templates.test.ts
index c51db81e..e8b21862 100644
--- a/tests/unit/email-templates.test.ts
+++ b/tests/unit/email-templates.test.ts
@@ -259,84 +259,47 @@ describe('managerDailyDigestEmail', () => {
 });
 
 describe('managerWeeklyDigestEmail', () => {
-  const base = {
-    weekStart: '2026-03-02',
-    weekEnd: '2026-03-08',
-    openPositions: [],
-  };
-
-  it('uses the new-applications subject when there is new activity', () => {
-    const result = managerWeeklyDigestEmail({
-      ...base,
-      newApplications: 12,
-      statusCounts: [],
-    });
-    expect(result.subject).toBe('Your week on Aplio: 12 new applications');
-  });
+  const base = { asOfDay: '2026-03-09', openPositions: [] };
 
-  it('singularizes the new-applications subject at exactly 1', () => {
+  it('sums the unresolved statuses into the subject, pluralized', () => {
     const result = managerWeeklyDigestEmail({
       ...base,
-      newApplications: 1,
-      statusCounts: [],
-    });
-    expect(result.subject).toBe('Your week on Aplio: 1 new application');
-  });
-
-  it('falls back to the awaiting-review subject with no new applications', () => {
-    const result = managerWeeklyDigestEmail({
-      ...base,
-      newApplications: 0,
-      statusCounts: [{ status: 'applied', count: 7 }],
+      statusCounts: [
+        { status: 'applied', count: 7 },
+        { status: 'reviewing', count: 3 },
+      ],
     });
-    expect(result.subject).toBe(
-      'Your week on Aplio: 7 applications awaiting review',
-    );
+    expect(result.subject).toBe('10 applications awaiting your review');
   });
 
-  it('excludes terminal decisions from the awaiting-review count', () => {
+  it('singularizes the subject at exactly 1', () => {
     const result = managerWeeklyDigestEmail({
       ...base,
-      newApplications: 0,
-      statusCounts: [
-        { status: 'applied', count: 7 },
-        { status: 'accepted', count: 3 },
-        { status: 'rejected', count: 2 },
-      ],
+      statusCounts: [{ status: 'applied', count: 1 }],
     });
-    expect(result.subject).toBe(
-      'Your week on Aplio: 7 applications awaiting review',
-    );
+    expect(result.subject).toBe('1 application awaiting your review');
   });
 
-  it('omits zero-count statuses and links each remaining status', () => {
+  it('renders a stat box per status, linked by status value', () => {
     const result = managerWeeklyDigestEmail({
       ...base,
-      newApplications: 0,
       statusCounts: [
         { status: 'applied', count: 7 },
-        { status: 'accepted', count: 3 },
+        { status: 'reviewing', count: 3 },
       ],
     });
     expect(result.html).toContain('?status=applied');
-    expect(result.html).toContain('?status=accepted');
-    expect(result.html).not.toContain('?status=rejected');
-  });
-
-  it('shows the empty statuses line when nothing is unresolved but new applications exist', () => {
-    const result = managerWeeklyDigestEmail({
-      ...base,
-      newApplications: 4,
-      statusCounts: [],
-    });
-    expect(result.html).toContain('No applications on your positions yet.');
+    expect(result.html).toContain('?status=reviewing');
+    expect(result.html).toContain('>7<');
+    expect(result.html).toContain('>3<');
+    expect(result.html).toContain('Applied');
+    expect(result.html).toContain('Reviewing');
   });
 
   it('shows the empty open-positions line with none open', () => {
     const result = managerWeeklyDigestEmail({
       ...base,
-      newApplications: 4,
-      statusCounts: [],
+      statusCounts: [{ status: 'applied', count: 1 }],
     });
     expect(result.html).toContain('You have no positions open right now.');
   });
@@ -344,8 +307,7 @@ describe('managerWeeklyDigestEmail', () => {
   it('links open positions by positionId', () => {
     const result = managerWeeklyDigestEmail({
       ...base,
-      newApplications: 4,
-      statusCounts: [],
+      statusCounts: [{ status: 'applied', count: 1 }],
       openPositions: [
         { positionId: 'pos-1', title: 'Senator' },
         { positionId: 'pos-2', title: 'Treasurer' },
@@ -355,25 +317,12 @@ describe('managerWeeklyDigestEmail', () => {
     expect(result.html).toContain('?positionId=pos-2');
   });
 
-  it('includes the week range and the manager footer', () => {
+  it('includes the as-of date and the manager footer', () => {
     const result = managerWeeklyDigestEmail({
       ...base,
-      newApplications: 4,
-      statusCounts: [],
+      statusCounts: [{ status: 'applied', count: 1 }],
     });
-    expect(result.html).toContain('Mar 2');
-    expect(result.html).toContain('Mar 8, 2026');
+    expect(result.html).toContain('Mar 9, 2026');
     expect(result.html).toContain(MANAGER_EMAIL_FOOTER);
   });
-
-  it('disambiguates a week range that crosses a year boundary', () => {
-    const result = managerWeeklyDigestEmail({
-      weekStart: '2026-12-28',
-      weekEnd: '2027-01-03',
-      openPositions: [],
-      newApplications: 4,
-      statusCounts: [],
-    });
-    expect(result.html).toContain('Dec 28, 2026 – Jan 3, 2027');
-  });
 });

From 0726d04f049c2a733d10d20fedf60440f60ab174 Mon Sep 17 00:00:00 2001
From: b-at-neu <winkler.b@northeastern.edu>
Date: Sat, 12 Sep 2026 11:21:53 -0400
Subject: [PATCH 09/35] #549 window the daily digest since each manager's last
 send

Replaces the previous-org-calendar-day window with a gap-safe one
anchored to each manager's own last digest (24h fallback for a
first-ever digest). A missed or delayed cron fire can no longer drop
an application, and in steady daily operation the window is still
always ~24h. The email now names the exact since-instant rather than
a calendar day, since the window can span more than a day after a gap.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 docs/WORKFLOWS.md                  |   8 +-
 lib/constants.ts                   |   5 ++
 lib/email/manager-digests.ts       |   2 +-
 lib/email/templates.ts             |  18 +++--
 lib/types.ts                       |   2 +-
 prisma/data/digests.ts             | 116 +++++++++++++++++++----------
 tests/db/manager-digests.test.ts   |  89 +++++++++++-----------
 tests/unit/email-templates.test.ts |  16 ++--
 8 files changed, 153 insertions(+), 103 deletions(-)

diff --git a/docs/WORKFLOWS.md b/docs/WORKFLOWS.md
index 0ff22b45..39e9a013 100644
--- a/docs/WORKFLOWS.md
+++ b/docs/WORKFLOWS.md
@@ -92,11 +92,11 @@ Three applicant-facing email _events_, over two rendered templates, all through
 
 ### XC-10 Manager digests
 
-Two cron-triggered emails on independent cadences that never gate each other, both gated per period by an `EmailLog` row rather than a per-manager "since last send."
+Two cron-triggered emails on independent cadences that never gate each other, neither backed by a stored "last sent" column.
 
-- **Daily** (`manager_daily_digest`) — `GET /api/cron/manager-daily-digest`, Vercel Cron at `0 12 * * *` UTC (08:00 ET). Covers the previous org calendar day. A manager with at least one new application on any managed position gets one email covering every such position, grouped, each linking to that position's filtered queue (`/manage/applications?positionId=<id>`); a manager with nothing new gets nothing.
-- **Weekly** (`manager_weekly_digest`) — `GET /api/cron/manager-weekly-digest`, Vercel Cron at `0 13 * * 1` UTC, Mondays. A reminder, not a recap: it has no time window on its own, and reports **every application still short of a terminal status** (not `accepted`/`rejected`/`withdrawn`/`draft`) across the manager's positions, however long it's been sitting there — a status count box per unresolved status (`/manage/applications?status=<value>`), plus the manager's currently-open positions as context. Sent only when that total is greater than zero; a manager with nothing outstanding gets nothing, regardless of how much happened that week.
-- **Idempotent per period, not per send.** Neither cadence has a stored "last sent" column — both are gated by whether an `EmailLog` row for that template already exists inside the current calendar day/week (`prisma/data/digests.ts`), so a double-fire is a no-op. A manager who manages several positions always gets **one** email per cadence, never one per position.
+- **Daily** (`manager_daily_digest`) — `GET /api/cron/manager-daily-digest`, Vercel Cron at `0 12 * * *` UTC (08:00 ET). Windowed **since each manager's own last digest** (any status, success or failure — a failed run isn't retried), falling back to `DAILY_DIGEST_LOOKBACK_MS` (24h) for a manager's first-ever digest. This is deliberately gap-safe rather than calendar-day-bounded: a missed or delayed cron fire never drops an application, and in steady daily operation the window is always ~24h anyway. A manager with at least one new application on any managed position gets one email covering every such position, grouped, each linking to that position's filtered queue (`/manage/applications?positionId=<id>`) and naming the exact since-instant (not a calendar day, since the window can span more after a gap); a manager with nothing new in their window gets nothing.
+- **Weekly** (`manager_weekly_digest`) — `GET /api/cron/manager-weekly-digest`, Vercel Cron at `0 13 * * 1` UTC, Mondays, gated per org calendar week (an `EmailLog` row already existing this week is a no-op). A reminder, not a recap: it has no time window on its own, and reports **every application still short of a terminal status** (not `accepted`/`rejected`/`withdrawn`/`draft`) across the manager's positions, however long it's been sitting there — a status count box per unresolved status (`/manage/applications?status=<value>`), plus the manager's currently-open positions as context. Sent only when that total is greater than zero; a manager with nothing outstanding gets nothing, regardless of how much happened that week.
+- **A manager who manages several positions always gets one email per cadence, never one per position.**
 - **Machine-authenticated, no principal.** Both routes reject any request whose `Authorization` header isn't `Bearer ${CRON_SECRET}` before touching the database (`lib/cron.ts`) — see `PERMISSIONS.md` → "Route access".
 - **Swallowed per recipient, like [XC-9](#xc-9-applicant-email) but for a different reason.** `lib/email/manager-digests.ts` catches each manager's send individually — Vercel Cron never retries a 200, so a thrown failure would only abandon every manager after the first bad address, not protect a mutation (there isn't one behind a digest). The `EmailLog` row, `failed` included, is the record; a failed digest is not retried within its period.
 - **Not a general job runner.** Each route computes and sends exactly the one digest its path names (`CLAUDE.md`'s allowlist).
diff --git a/lib/constants.ts b/lib/constants.ts
index 91d10135..3a71ba7f 100644
--- a/lib/constants.ts
+++ b/lib/constants.ts
@@ -1130,6 +1130,11 @@ export const EMAIL_TEMPLATE_VALUES = [
 // Keeps a digest run under Resend's 2 req/s (docs.resend.com/api-reference/introduction#rate-limit).
 export const MANAGER_DIGEST_SEND_SPACING_MS = 600;
 
+// Daily digest fallback window for a manager with no prior digest — every
+// later run instead windows from that manager's own last digest, so a
+// missed/delayed cron fire never drops a gap of applications.
+export const DAILY_DIGEST_LOOKBACK_MS = 24 * 60 * 60 * 1000;
+
 export const EMAIL_STATUS_LABELS: Record<$Enums.EmailStatus, string> = {
   scheduled: 'Scheduled',
   sent: 'Sent',
diff --git a/lib/email/manager-digests.ts b/lib/email/manager-digests.ts
index d4f9a080..91b9783f 100644
--- a/lib/email/manager-digests.ts
+++ b/lib/email/manager-digests.ts
@@ -31,7 +31,7 @@ export async function dispatchDailyManagerDigests(
     try {
       const { subject, html, text } = managerDailyDigestEmail({
         firstName: getFirstName(recipient.name),
-        day: recipient.day,
+        since: recipient.since,
         positions: recipient.positions,
         total: recipient.total,
       });
diff --git a/lib/email/templates.ts b/lib/email/templates.ts
index d0de1c1a..00af7631 100644
--- a/lib/email/templates.ts
+++ b/lib/email/templates.ts
@@ -4,7 +4,7 @@ import { type $Enums } from '@/prisma/client';
 
 import { getBaseUrl } from '@/lib/base-url';
 import { APPLICATION_STATUS_LABELS, ORG_TIMEZONE } from '@/lib/constants';
-import { orgDayStart } from '@/lib/dates';
+import { formatInstant, orgDayStart } from '@/lib/dates';
 import {
   type ManagerDigestPosition,
   type WeeklyDigestStatusCount,
@@ -275,20 +275,26 @@ function formatDigestDay(day: string): string {
 
 export interface ManagerDailyDigestEmailOptions {
   firstName?: string;
-  day: string;
+  since: Date;
   positions: ManagerDigestPosition[];
   total: number;
 }
 
+// `since` is an instant, not a calendar day — the window is "since your last
+// digest," which can span more than a day after a missed/delayed run, so the
+// copy names the exact moment rather than a single date.
 export function managerDailyDigestEmail({
   firstName,
-  day,
+  since,
   positions,
   total,
 }: ManagerDailyDigestEmailOptions): EmailTemplate {
   const baseUrl = getBaseUrl();
   const allApplicationsUrl = `${baseUrl}/manage/applications`;
-  const dayLabel = formatDigestDay(day);
+  const sinceLabel = formatInstant(since, {
+    precision: 'datetime',
+    timeZone: ORG_TIMEZONE,
+  });
   const safeGreeting = escapeHtml(greeting(firstName));
 
   const subject =
@@ -305,7 +311,7 @@ export function managerDailyDigestEmail({
 
   const content = `
     <p style="margin:0 0 16px;font-size:14px;color:#09090b;">${safeGreeting}</p>
-    <p style="margin:0 0 16px;font-size:14px;color:#71717a;">New applications on the positions you manage, from <strong>${escapeHtml(dayLabel)}</strong>.</p>
+    <p style="margin:0 0 16px;font-size:14px;color:#71717a;">New applications on the positions you manage, since <strong>${escapeHtml(sinceLabel)}</strong>.</p>
     <div style="margin:0 0 24px;">${positionRows}</div>
     ${primaryButton(allApplicationsUrl, 'Review all applications')}
   `;
@@ -313,7 +319,7 @@ export function managerDailyDigestEmail({
   const text = [
     greeting(firstName),
     '',
-    `New applications on the positions you manage, from ${dayLabel}.`,
+    `New applications on the positions you manage, since ${sinceLabel}.`,
     '',
     ...positions.map(
       (position) =>
diff --git a/lib/types.ts b/lib/types.ts
index 376859d2..87667a87 100644
--- a/lib/types.ts
+++ b/lib/types.ts
@@ -538,7 +538,7 @@ export type DailyDigestRecipient = {
   userId: string;
   email: string;
   name: string | null;
-  day: string;
+  since: Date;
   positions: ManagerDigestPosition[];
   total: number;
 };
diff --git a/prisma/data/digests.ts b/prisma/data/digests.ts
index caf69e28..76267879 100644
--- a/prisma/data/digests.ts
+++ b/prisma/data/digests.ts
@@ -3,16 +3,12 @@ import 'server-only';
 import { type $Enums } from '@/prisma/client';
 
 import {
+  DAILY_DIGEST_LOOKBACK_MS,
   NON_REVIEWABLE_APPLICATION_STATUSES,
   PUBLISHED_POSITION_WHERE,
   UNRESOLVED_APPLICATION_STATUSES,
 } from '@/lib/constants';
-import {
-  currentOrgWeekStart,
-  orgDayStart,
-  previousOrgDay,
-  toOrgDayString,
-} from '@/lib/dates';
+import { currentOrgWeekStart, orgDayStart, toOrgDayString } from '@/lib/dates';
 import { prisma } from '@/lib/prisma';
 import {
   type DailyDigestRecipient,
@@ -60,26 +56,49 @@ async function getManagerCandidates(): Promise<ManagerCandidate[]> {
   });
 }
 
-async function tallyNewApplications(
+// Raw rows, not a groupBy count — the daily digest windows per manager (each
+// manager's own last-digest cutoff), so the count per position can't be
+// pre-aggregated until each manager's cutoff is known.
+async function fetchNewApplications(
   positionIds: string[],
-  start: Date,
-  end: Date,
-): Promise<Map<string, number>> {
-  if (positionIds.length === 0) return new Map();
+  since: Date,
+  until: Date,
+): Promise<{ positionId: string; submittedAt: Date }[]> {
+  if (positionIds.length === 0) return [];
 
-  const rows = await prisma.application.groupBy({
-    by: ['positionId'],
+  return prisma.application.findMany({
     where: {
       positionId: { in: positionIds },
       deletedAt: null,
       status: { notIn: NON_REVIEWABLE_APPLICATION_STATUSES },
-      submittedAt: { gte: start, lte: end },
+      submittedAt: { gt: since, lte: until },
       position: PUBLISHED_POSITION_WHERE,
     },
-    _count: true,
+    select: { positionId: true, submittedAt: true },
+  });
+}
+
+// A manager's own last `manager_daily_digest` row (success or failure — a
+// failed run isn't retried, same as before) anchors their next window, so a
+// missed/delayed cron fire can never drop a gap; a manager never digested
+// before falls back to DAILY_DIGEST_LOOKBACK_MS.
+async function getDigestSinceByManager(
+  managerIds: string[],
+  fallback: Date,
+): Promise<Map<string, Date>> {
+  if (managerIds.length === 0) return new Map();
+
+  const rows = await prisma.emailLog.groupBy({
+    by: ['userId'],
+    where: { template: 'manager_daily_digest', userId: { in: managerIds } },
+    _max: { createdAt: true },
   });
 
-  return new Map(rows.map((row) => [row.positionId, row._count]));
+  const since = new Map<string, Date>();
+  for (const row of rows)
+    if (row.userId !== null)
+      since.set(row.userId, row._max.createdAt ?? fallback);
+  return since;
 }
 
 async function tallyStatusBreakdown(
@@ -109,7 +128,13 @@ async function tallyStatusBreakdown(
   return map;
 }
 
-/** Managers with new applications yesterday, minus any already digested today (counted in `skipped`). */
+/**
+ * Managers with new applications since their own last daily digest (or the
+ * lookback fallback, for a first-ever digest). A manager with nothing new in
+ * their window is counted in `skipped`, whether that's genuinely no activity
+ * or a repeat call shortly after a successful send — both collapse to the
+ * same "nothing since last time" outcome.
+ */
 export async function getDailyDigestRecipients(
   now: Date = new Date(),
 ): Promise<{ recipients: DailyDigestRecipient[]; skipped: number }> {
@@ -117,36 +142,44 @@ export async function getDailyDigestRecipients(
   if (managers.length === 0) return { recipients: [], skipped: 0 };
 
   const managerIds = managers.map((manager) => manager.id);
-  const { day, start, end } = previousOrgDay(now);
-
-  const alreadyDigested = await prisma.emailLog.findMany({
-    where: {
-      template: 'manager_daily_digest',
-      userId: { in: managerIds },
-      createdAt: { gte: orgDayStart(toOrgDayString(now)) },
-    },
-    select: { userId: true },
-  });
-  const gatedIds = new Set(
-    alreadyDigested.map((row) => row.userId).filter((id) => id !== null),
+  const fallbackSince = new Date(now.getTime() - DAILY_DIGEST_LOOKBACK_MS);
+  const sinceByManager = await getDigestSinceByManager(
+    managerIds,
+    fallbackSince,
   );
 
-  const candidates = managers.filter((manager) => !gatedIds.has(manager.id));
-  if (candidates.length === 0)
-    return { recipients: [], skipped: gatedIds.size };
-
-  const positionIds = candidates.flatMap((manager) =>
+  const positionIds = managers.flatMap((manager) =>
     manager.managedPositions.map((position) => position.id),
   );
-  const tallies = await tallyNewApplications(positionIds, start, end);
+  const earliestSince = managers.reduce((earliest, manager) => {
+    const since = sinceByManager.get(manager.id) ?? fallbackSince;
+    return since < earliest ? since : earliest;
+  }, fallbackSince);
+
+  const applications = await fetchNewApplications(
+    positionIds,
+    earliestSince,
+    now,
+  );
+  const submittedAtByPosition = new Map<string, Date[]>();
+  for (const application of applications) {
+    const list = submittedAtByPosition.get(application.positionId) ?? [];
+    list.push(application.submittedAt);
+    submittedAtByPosition.set(application.positionId, list);
+  }
 
   const recipients: DailyDigestRecipient[] = [];
-  for (const manager of candidates) {
+  let skipped = 0;
+  for (const manager of managers) {
+    const since = sinceByManager.get(manager.id) ?? fallbackSince;
+
     const positions: ManagerDigestPosition[] = manager.managedPositions
       .map((position) => ({
         positionId: position.id,
         title: position.title,
-        newApplications: tallies.get(position.id) ?? 0,
+        newApplications: (submittedAtByPosition.get(position.id) ?? []).filter(
+          (submittedAt) => submittedAt > since,
+        ).length,
       }))
       .filter((position) => position.newApplications > 0)
       .sort((a, b) => a.title.localeCompare(b.title));
@@ -155,19 +188,22 @@ export async function getDailyDigestRecipients(
       (sum, position) => sum + position.newApplications,
       0,
     );
-    if (total === 0) continue;
+    if (total === 0) {
+      skipped += 1;
+      continue;
+    }
 
     recipients.push({
       userId: manager.id,
       email: manager.email,
       name: manager.name,
-      day,
+      since,
       positions,
       total,
     });
   }
 
-  return { recipients, skipped: gatedIds.size };
+  return { recipients, skipped };
 }
 
 /** Managers with any application still short of a terminal status, gated per org week. */
diff --git a/tests/db/manager-digests.test.ts b/tests/db/manager-digests.test.ts
index c23e2cdc..df3f4874 100644
--- a/tests/db/manager-digests.test.ts
+++ b/tests/db/manager-digests.test.ts
@@ -18,7 +18,6 @@ import {
 
 import type { Position, User } from '@/prisma/client';
 
-import { orgDayStart, previousOrgDay, toOrgDayString } from '@/lib/dates';
 import { prisma } from '@/lib/prisma';
 
 const mockSend = vi.fn();
@@ -104,15 +103,12 @@ describe('daily digest', () => {
     position2 = await createTestPosition(creator, { managers: [manager] });
   });
 
-  it('sends one email covering two positions submitted yesterday, logged once', async () => {
-    const yesterday = previousOrgDay(new Date());
-    const submittedAt = new Date(yesterday.start.getTime() + 60 * 60 * 1000);
-
+  it('sends one email covering two positions with recent applications, logged once', async () => {
     const applicantA = await createTestUser();
     const applicantB = await createTestUser();
-    await createTestApplication(applicantA, position1, { submittedAt });
-    await createTestApplication(applicantB, position1, { submittedAt });
-    await createTestApplication(applicantA, position2, { submittedAt });
+    await createTestApplication(applicantA, position1, {});
+    await createTestApplication(applicantB, position1, {});
+    await createTestApplication(applicantA, position2, {});
 
     const res = await dailyGET(makeRequest(DAILY_URL, `Bearer ${CRON_SECRET}`));
     expect(res.status).toBe(200);
@@ -130,33 +126,26 @@ describe('daily digest', () => {
     expect(logs[0]?.applicationId).toBeNull();
   });
 
-  it('excludes submissions from today and from two days ago', async () => {
+  it('only looks back the fallback window for a manager never digested before', async () => {
     const now = new Date();
-    const todaySubmittedAt = new Date(
-      orgDayStart(toOrgDayString(now)).getTime() + 60 * 60 * 1000,
-    );
-    const twoDaysAgo = previousOrgDay(previousOrgDay(now).start);
-    const twoDaysAgoSubmittedAt = new Date(
-      twoDaysAgo.start.getTime() + 60 * 60 * 1000,
-    );
+    const tooOld = new Date(now.getTime() - 25 * 60 * 60 * 1000);
+    const withinLookback = new Date(now.getTime() - 23 * 60 * 60 * 1000);
 
-    const applicantToday = await createTestUser();
-    const applicantTwoDaysAgo = await createTestUser();
-    await createTestApplication(applicantToday, position1, {
-      submittedAt: todaySubmittedAt,
+    const applicantOld = await createTestUser();
+    const applicantRecent = await createTestUser();
+    await createTestApplication(applicantOld, position1, {
+      submittedAt: tooOld,
     });
-    await createTestApplication(applicantTwoDaysAgo, position1, {
-      submittedAt: twoDaysAgoSubmittedAt,
+    await createTestApplication(applicantRecent, position1, {
+      submittedAt: withinLookback,
     });
 
     const res = await dailyGET(makeRequest(DAILY_URL, `Bearer ${CRON_SECRET}`));
     expect(res.status).toBe(200);
-    expect(sentTo(manager.email)).toBeUndefined();
 
-    const logs = await prisma.emailLog.findMany({
-      where: { userId: manager.id, template: 'manager_daily_digest' },
-    });
-    expect(logs).toHaveLength(0);
+    const call = sentTo(manager.email);
+    expect(call).toBeDefined();
+    expect(call?.subject).toBe(`1 new application for ${position1.title}`);
   });
 
   it('sends nothing to a manager with no new activity', async () => {
@@ -165,11 +154,9 @@ describe('daily digest', () => {
     expect(sentTo(manager.email)).toBeUndefined();
   });
 
-  it('gates a repeat call the same day after a successful send', async () => {
-    const yesterday = previousOrgDay(new Date());
-    const submittedAt = new Date(yesterday.start.getTime() + 60 * 60 * 1000);
+  it('finds nothing new when called again immediately after a successful send', async () => {
     const applicant = await createTestUser();
-    await createTestApplication(applicant, position1, { submittedAt });
+    await createTestApplication(applicant, position1, {});
 
     const first = await dailyGET(
       makeRequest(DAILY_URL, `Bearer ${CRON_SECRET}`),
@@ -192,19 +179,40 @@ describe('daily digest', () => {
     expect(logs).toHaveLength(1);
   });
 
-  it('does not stop the run when one recipient send fails, and records it as failed', async () => {
-    const yesterday = previousOrgDay(new Date());
-    const submittedAt = new Date(yesterday.start.getTime() + 60 * 60 * 1000);
+  it('still reports an application submitted after the previous send, even later the same day', async () => {
+    const firstApplicant = await createTestUser();
+    await createTestApplication(firstApplicant, position1, {});
 
+    const first = await dailyGET(
+      makeRequest(DAILY_URL, `Bearer ${CRON_SECRET}`),
+    );
+    expect(first.status).toBe(200);
+    expect(sentTo(manager.email)).toBeDefined();
+
+    mockSend.mockClear();
+
+    const secondApplicant = await createTestUser();
+    await createTestApplication(secondApplicant, position1, {});
+
+    const second = await dailyGET(
+      makeRequest(DAILY_URL, `Bearer ${CRON_SECRET}`),
+    );
+    expect(second.status).toBe(200);
+    const call = sentTo(manager.email);
+    expect(call).toBeDefined();
+    expect(call?.subject).toBe(`1 new application for ${position1.title}`);
+  });
+
+  it('does not stop the run when one recipient send fails, and records it as failed', async () => {
     const applicant = await createTestUser();
-    await createTestApplication(applicant, position1, { submittedAt });
+    await createTestApplication(applicant, position1, {});
 
     const managerOk = await createTestUser();
     const positionOk = await createTestPosition(creator, {
       managers: [managerOk],
     });
     const applicantOk = await createTestUser();
-    await createTestApplication(applicantOk, positionOk, { submittedAt });
+    await createTestApplication(applicantOk, positionOk, {});
 
     mockSend.mockImplementation(async (args: { to: string }) => {
       if (args.to === manager.email) throw new Error('simulated send failure');
@@ -227,17 +235,12 @@ describe('daily digest', () => {
   });
 
   it('excludes a deactivated manager and a manager who only manages a draft position', async () => {
-    const yesterday = previousOrgDay(new Date());
-    const submittedAt = new Date(yesterday.start.getTime() + 60 * 60 * 1000);
-
     const deactivatedManager = await createTestUser({ deletedAt: new Date() });
     const deactivatedManagerPosition = await createTestPosition(creator, {
       managers: [deactivatedManager],
     });
     const applicantA = await createTestUser();
-    await createTestApplication(applicantA, deactivatedManagerPosition, {
-      submittedAt,
-    });
+    await createTestApplication(applicantA, deactivatedManagerPosition, {});
 
     const draftOnlyManager = await createTestUser();
     const draftPosition = await createTestPosition(creator, {
@@ -245,7 +248,7 @@ describe('daily digest', () => {
       status: 'draft',
     });
     const applicantB = await createTestUser();
-    await createTestApplication(applicantB, draftPosition, { submittedAt });
+    await createTestApplication(applicantB, draftPosition, {});
 
     const res = await dailyGET(makeRequest(DAILY_URL, `Bearer ${CRON_SECRET}`));
     expect(res.status).toBe(200);
diff --git a/tests/unit/email-templates.test.ts b/tests/unit/email-templates.test.ts
index e8b21862..7aba4737 100644
--- a/tests/unit/email-templates.test.ts
+++ b/tests/unit/email-templates.test.ts
@@ -183,7 +183,7 @@ describe('managerDailyDigestEmail', () => {
   it('singularizes the subject and body at exactly 1', () => {
     const result = managerDailyDigestEmail({
       firstName: 'Jane',
-      day: '2026-03-02',
+      since: new Date('2026-03-02T14:00:00.000Z'),
       positions: [
         { positionId: 'pos-1', title: 'Treasurer', newApplications: 1 },
       ],
@@ -195,7 +195,7 @@ describe('managerDailyDigestEmail', () => {
 
   it('names the single position in the subject, pluralized', () => {
     const result = managerDailyDigestEmail({
-      day: '2026-03-02',
+      since: new Date('2026-03-02T14:00:00.000Z'),
       positions: [
         { positionId: 'pos-1', title: 'Treasurer', newApplications: 3 },
       ],
@@ -206,7 +206,7 @@ describe('managerDailyDigestEmail', () => {
 
   it('summarizes across positions in the subject when there is more than one', () => {
     const result = managerDailyDigestEmail({
-      day: '2026-03-02',
+      since: new Date('2026-03-02T14:00:00.000Z'),
       positions: [
         { positionId: 'pos-1', title: 'Senator', newApplications: 3 },
         { positionId: 'pos-2', title: 'Treasurer', newApplications: 2 },
@@ -218,7 +218,7 @@ describe('managerDailyDigestEmail', () => {
 
   it('escapes a dangerous position title in the html but leaves the subject raw', () => {
     const result = managerDailyDigestEmail({
-      day: '2026-03-02',
+      since: new Date('2026-03-02T14:00:00.000Z'),
       positions: [
         { positionId: 'pos-1', title: DANGEROUS_TITLE, newApplications: 1 },
       ],
@@ -232,7 +232,7 @@ describe('managerDailyDigestEmail', () => {
 
   it('links every position row to its own positionId', () => {
     const result = managerDailyDigestEmail({
-      day: '2026-03-02',
+      since: new Date('2026-03-02T14:00:00.000Z'),
       positions: [
         { positionId: 'pos-1', title: 'Senator', newApplications: 3 },
         { positionId: 'pos-2', title: 'Treasurer', newApplications: 2 },
@@ -245,15 +245,15 @@ describe('managerDailyDigestEmail', () => {
     expect(result.text).toContain('?positionId=pos-2');
   });
 
-  it('names the org day and includes the manager footer', () => {
+  it('names the exact since-instant and includes the manager footer', () => {
     const result = managerDailyDigestEmail({
-      day: '2026-03-02',
+      since: new Date('2026-03-02T14:00:00.000Z'),
       positions: [
         { positionId: 'pos-1', title: 'Treasurer', newApplications: 1 },
       ],
       total: 1,
     });
-    expect(result.html).toContain('Mar 2, 2026');
+    expect(result.html).toContain('Mar 2, 2026, 9:00 AM EST');
     expect(result.html).toContain(MANAGER_EMAIL_FOOTER);
   });
 });

From e56c3b707dc4340ee23b31a0bdbb3e222c2b79e1 Mon Sep 17 00:00:00 2001
From: b-at-neu <winkler.b@northeastern.edu>
Date: Sat, 12 Sep 2026 11:27:34 -0400
Subject: [PATCH 10/35] #549 address review feedback

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 lib/email/templates.ts | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/lib/email/templates.ts b/lib/email/templates.ts
index 00af7631..fc5b0c4d 100644
--- a/lib/email/templates.ts
+++ b/lib/email/templates.ts
@@ -340,9 +340,8 @@ export function managerDailyDigestEmail({
   };
 }
 
-// Only the two variants an unresolved status can carry (see
-// APPLICATION_STATUS_BADGE_VARIANT) — reviewing is the sole 'warning', the
-// rest are 'info'. Matches the in-app status-dot palette (app/globals.css).
+// Matches the in-app status-dot palette — reviewing is the sole 'warning'
+// (APPLICATION_STATUS_BADGE_VARIANT), the rest are 'info'.
 const DIGEST_STATUS_DOT_COLOR: Partial<
   Record<$Enums.ApplicationStatus, string>
 > = {

From c279e85000a484cc83886075944151386ac3062d Mon Sep 17 00:00:00 2001
From: b-at-neu <winkler.b@northeastern.edu>
Date: Wed, 23 Sep 2026 19:59:25 -0400
Subject: [PATCH 11/35] #549 handle nullable submittedAt after rebasing onto
 #747
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

#747 (merged to dev after this branch's last rebase) dropped the
default and made Application.submittedAt nullable — a draft no longer
has a fake submission timestamp. fetchNewApplications already excludes
drafts by status, so the null case can't occur in practice; narrow the
type back with a filter rather than loosening the daily digest's own
types to Date | null everywhere downstream.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 prisma/data/digests.ts | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/prisma/data/digests.ts b/prisma/data/digests.ts
index 76267879..67fef5ea 100644
--- a/prisma/data/digests.ts
+++ b/prisma/data/digests.ts
@@ -66,7 +66,7 @@ async function fetchNewApplications(
 ): Promise<{ positionId: string; submittedAt: Date }[]> {
   if (positionIds.length === 0) return [];
 
-  return prisma.application.findMany({
+  const rows = await prisma.application.findMany({
     where: {
       positionId: { in: positionIds },
       deletedAt: null,
@@ -76,6 +76,13 @@ async function fetchNewApplications(
     },
     select: { positionId: true, submittedAt: true },
   });
+
+  // Only a draft has a null submittedAt, and drafts are already excluded by
+  // status above — this narrows the type back from the nullable column.
+  return rows.filter(
+    (row): row is { positionId: string; submittedAt: Date } =>
+      row.submittedAt !== null,
+  );
 }
 
 // A manager's own last `manager_daily_digest` row (success or failure — a

From 025c989f1d8b6e99df9f59f40c5a5a58027c8723 Mon Sep 17 00:00:00 2001
From: Ciel Bellerose <kcbellerose@icloud.com>
Date: Wed, 23 Sep 2026 21:08:28 -0400
Subject: [PATCH 12/35] #769 highlight the section actually in view in section
 nav

Replace the IntersectionObserver-based active section detection with
scroll-position measurements. The old approach let an edge-only overlap
of the previous section win over the section actually being read, and
never let the last section highlight once the user was already at the
bottom of the page.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 components/layouts/section-nav-list.tsx |   4 +-
 components/layouts/use-section-nav.ts   | 108 +++++++++++++++--------
 docs/DESIGN.md                          |   2 +-
 lib/section-nav.ts                      |  43 ++++++---
 lib/types.ts                            |  13 ++-
 tests/unit/section-nav.test.ts          | 110 +++++++++++++++++-------
 6 files changed, 194 insertions(+), 86 deletions(-)

diff --git a/components/layouts/section-nav-list.tsx b/components/layouts/section-nav-list.tsx
index 3434708e..64ea4e73 100644
--- a/components/layouts/section-nav-list.tsx
+++ b/components/layouts/section-nav-list.tsx
@@ -5,6 +5,8 @@ import type { MouseEvent } from 'react';
 import type { SectionNavItem } from '@/lib/types';
 import { cn } from '@/lib/utils';
 
+import { scrollToSection } from '@/components/layouts/use-section-nav';
+
 interface SectionNavListProps {
   sections: SectionNavItem[];
   activeId: string | null;
@@ -59,6 +61,6 @@ function handleClick(
   );
   onNavigate?.();
   requestAnimationFrame(() => {
-    document.getElementById(id)?.scrollIntoView({ block: 'start' });
+    scrollToSection(id);
   });
 }
diff --git a/components/layouts/use-section-nav.ts b/components/layouts/use-section-nav.ts
index 8b54bdcf..1d82a45e 100644
--- a/components/layouts/use-section-nav.ts
+++ b/components/layouts/use-section-nav.ts
@@ -4,12 +4,11 @@ import { usePathname } from 'next/navigation';
 import { useEffect, useState } from 'react';
 
 import {
-  SECTION_NAV_ROOT_MARGIN,
   SECTION_NAV_SELECTOR,
   buildSectionNavItems,
   selectActiveSectionId,
 } from '@/lib/section-nav';
-import type { SectionNavItem } from '@/lib/types';
+import type { SectionNavItem, SectionPosition } from '@/lib/types';
 
 interface UseSectionNavResult {
   sections: SectionNavItem[];
@@ -27,6 +26,27 @@ function sectionsKey(sections: SectionNavItem[]): string {
   return sections.map((s) => `${s.id}|${s.label}`).join(',');
 }
 
+let pin: { id: string; settled: boolean } | null = null;
+let settleTimer: ReturnType<typeof setTimeout> | null = null;
+
+function armSettleTimer(): void {
+  if (settleTimer !== null) clearTimeout(settleTimer);
+  settleTimer = setTimeout(() => {
+    if (pin) pin.settled = true;
+  }, 150);
+}
+
+// Module-level: the desktop sidebar and mobile Sheet each mount their own
+// useSectionNav, and the Sheet unmounts right after a click.
+export function scrollToSection(id: string): void {
+  pin = { id, settled: false };
+  document
+    .getElementById('main-content')
+    ?.dispatchEvent(new Event('section-nav:pin'));
+  document.getElementById(id)?.scrollIntoView({ block: 'start' });
+  armSettleTimer();
+}
+
 // Sole permitted useEffect: subscribes to native observers, not data fetching.
 export function useSectionNav(): UseSectionNavResult {
   const pathname = usePathname();
@@ -42,15 +62,37 @@ export function useSectionNav(): UseSectionNavResult {
     let activeId: string | null = null;
     let skipNextHashSync = true;
     let hasScrolledToInitialHash = false;
-    const visibility = new Map<string, boolean>();
-    let observer: IntersectionObserver | null = null;
+    let rafId: number | null = null;
+
+    function scheduleCompute(): void {
+      if (rafId !== null) return;
+      rafId = requestAnimationFrame(() => {
+        rafId = null;
+        computeActive();
+      });
+    }
 
     function computeActive(): void {
-      const entries = currentSections.map((section) => ({
-        id: section.id,
-        isIntersecting: visibility.get(section.id) ?? false,
-      }));
-      const next = selectActiveSectionId(entries, activeId);
+      const rootTop = main.getBoundingClientRect().top;
+      const positions: SectionPosition[] = [];
+      for (const section of currentSections) {
+        const el = document.getElementById(section.id);
+        if (!el) continue;
+        positions.push({
+          id: section.id,
+          top: el.getBoundingClientRect().top - rootTop,
+        });
+      }
+
+      const next = selectActiveSectionId(
+        positions,
+        {
+          scrollTop: main.scrollTop,
+          scrollHeight: main.scrollHeight,
+          clientHeight: main.clientHeight,
+        },
+        pin?.id ?? null,
+      );
       if (next === activeId) return;
 
       activeId = next;
@@ -68,27 +110,10 @@ export function useSectionNav(): UseSectionNavResult {
         );
     }
 
-    function subscribe(): void {
-      observer?.disconnect();
-      visibility.clear();
-      if (currentSections.length === 0) {
-        observer = null;
-        return;
-      }
-
-      observer = new IntersectionObserver(
-        (observerEntries) => {
-          for (const entry of observerEntries)
-            visibility.set(entry.target.id, entry.isIntersecting);
-          computeActive();
-        },
-        { root: main, rootMargin: SECTION_NAV_ROOT_MARGIN, threshold: 0 },
-      );
-
-      for (const section of currentSections) {
-        const el = document.getElementById(section.id);
-        if (el) observer.observe(el);
-      }
+    function handleScroll(): void {
+      if (pin?.settled) pin = null;
+      else if (pin) armSettleTimer();
+      scheduleCompute();
     }
 
     function scrollToInitialHashIfPresent(): void {
@@ -99,27 +124,34 @@ export function useSectionNav(): UseSectionNavResult {
       if (!matches) return;
 
       hasScrolledToInitialHash = true;
-      document.getElementById(hashId)?.scrollIntoView({ block: 'start' });
+      scrollToSection(hashId);
     }
 
     function refresh(): void {
       const discovered = discoverSections(main);
-      if (sectionsKey(discovered) === sectionsKey(currentSections)) return;
-
-      currentSections = discovered;
-      setSections(discovered);
-      subscribe();
-      scrollToInitialHashIfPresent();
+      if (sectionsKey(discovered) !== sectionsKey(currentSections)) {
+        currentSections = discovered;
+        setSections(discovered);
+        scrollToInitialHashIfPresent();
+      }
+      scheduleCompute();
     }
 
     refresh();
 
+    main.addEventListener('scroll', handleScroll, { passive: true });
+    main.addEventListener('section-nav:pin', scheduleCompute);
+    const resizeObserver = new ResizeObserver(scheduleCompute);
+    resizeObserver.observe(main);
     const mutationObserver = new MutationObserver(refresh);
     mutationObserver.observe(main, { childList: true, subtree: true });
 
     return () => {
-      observer?.disconnect();
+      main.removeEventListener('scroll', handleScroll);
+      main.removeEventListener('section-nav:pin', scheduleCompute);
+      resizeObserver.disconnect();
       mutationObserver.disconnect();
+      if (rafId !== null) cancelAnimationFrame(rafId);
       setSections([]);
       setActiveSectionId(null);
     };
diff --git a/docs/DESIGN.md b/docs/DESIGN.md
index e8fb8a0d..40ed2559 100644
--- a/docs/DESIGN.md
+++ b/docs/DESIGN.md
@@ -66,7 +66,7 @@ Any change to a brand/status token must keep ≥4.5:1 contrast against its paire
 - **Forms:** use the shadcn `Form`/`FieldGroup` primitives with `FormLabel`; every input has an associated label; surface validation with `data-invalid` / inline `FormMessage`, not ad-hoc text. (Form wiring rules: `ENGINEERING.md` §4.)
 - **State surfaces:** all three required (`ENGINEERING.md` §4) — `<Suspense>` + skeleton for loading, `error.tsx`/inline error for failure, a designed empty state (icon + one line + primary action) for zero items. Secondary cards on a detail page may opt into `SectionCardEmpty`'s compact variant (one muted line, no icon/action) instead — the roomy form stays the default for dashboards.
 - **Focus & overlays:** never `outline-none` without a visible replacement; rely on Radix focus trapping in dialogs/sheets — don't break it with custom wrappers.
-- **Section sub-nav.** A page section opts into the sidebar's in-page nav by giving its outermost `<section>` an `id` plus `data-section-nav="<Label>"` (matching its visible heading) and `scroll-mt-6`. The sidebar discovers these from the DOM under the active nav item — nothing to register elsewhere, and a group that never renders (e.g. an empty position status) contributes nothing. Fewer than two opted-in sections on a page renders no sub-nav. This is secondary navigation only — never the sole way to reach a section; every opted-in section must also be reachable by scrolling.
+- **Section sub-nav.** A page section opts into the sidebar's in-page nav by giving its outermost `<section>` an `id` plus `data-section-nav="<Label>"` (matching its visible heading) and `scroll-mt-6`. The sidebar discovers these from the DOM under the active nav item — nothing to register elsewhere, and a group that never renders (e.g. an empty position status) contributes nothing. Fewer than two opted-in sections on a page renders no sub-nav. This is secondary navigation only — never the sole way to reach a section; every opted-in section must also be reachable by scrolling. The highlighted item is the last section whose top has crossed the middle of the scroll area. At the top of the page it is the first section, at the bottom the last, and after a click the clicked section until the user scrolls again.
 
 ## 6. Iconography
 
diff --git a/lib/section-nav.ts b/lib/section-nav.ts
index 467fb6d2..a6942878 100644
--- a/lib/section-nav.ts
+++ b/lib/section-nav.ts
@@ -1,10 +1,17 @@
-import type { SectionNavItem, SectionVisibility } from '@/lib/types';
+import type {
+  SectionNavItem,
+  SectionPosition,
+  SectionScrollMetrics,
+} from '@/lib/types';
 
 // Discovery selector for use-section-nav's querySelectorAll/MutationObserver scan.
 export const SECTION_NAV_SELECTOR = '[data-section-nav][id]';
 
-// Top 30% of <main> — tall enough that some section overlaps it at any mid-page scroll position.
-export const SECTION_NAV_ROOT_MARGIN = '0px 0px -70% 0px';
+// Reading line: the fraction of clientHeight a section's top must cross to win.
+export const SECTION_NAV_READING_LINE = 0.5;
+
+// Slack for the top/bottom-of-page checks, in px.
+export const SECTION_NAV_EDGE_TOLERANCE_PX = 1;
 
 // Preserves document order; drops empty/duplicate ids or labels; fewer than
 // two survivors means no sub-nav.
@@ -24,20 +31,32 @@ export function buildSectionNavItems(
   return items.length >= 2 ? items : [];
 }
 
-// First intersecting entry in document order wins. When none intersects,
-// keep previousId if it's still in the list, else fall back to the first.
+// Order: pinned id, top of page, bottom of page, else the last section whose
+// top has crossed the reading line (falling back to the first).
 export function selectActiveSectionId(
-  visibility: SectionVisibility[],
-  previousId: string | null,
+  sections: SectionPosition[],
+  metrics: SectionScrollMetrics,
+  pinnedId: string | null,
 ): string | null {
-  const [first] = visibility;
+  const [first] = sections;
   if (!first) return null;
 
-  const intersecting = visibility.find((entry) => entry.isIntersecting);
-  if (intersecting) return intersecting.id;
+  if (pinnedId && sections.some((section) => section.id === pinnedId))
+    return pinnedId;
+
+  const { scrollTop, scrollHeight, clientHeight } = metrics;
+  if (scrollTop <= SECTION_NAV_EDGE_TOLERANCE_PX) return first.id;
+
+  const last = sections[sections.length - 1];
+  if (
+    last &&
+    scrollTop + clientHeight >= scrollHeight - SECTION_NAV_EDGE_TOLERANCE_PX
+  )
+    return last.id;
 
-  if (previousId && visibility.some((entry) => entry.id === previousId))
-    return previousId;
+  const readingLine = clientHeight * SECTION_NAV_READING_LINE;
+  for (const section of [...sections].reverse())
+    if (section.top <= readingLine) return section.id;
 
   return first.id;
 }
diff --git a/lib/types.ts b/lib/types.ts
index f4983db7..59a46eda 100644
--- a/lib/types.ts
+++ b/lib/types.ts
@@ -491,10 +491,17 @@ export interface SectionNavItem {
   label: string;
 }
 
-// One IntersectionObserver entry, reduced to what selectActiveSectionId needs.
-export interface SectionVisibility {
+// A section's top offset in px from the scroll root's top edge.
+export interface SectionPosition {
   id: string;
-  isIntersecting: boolean;
+  top: number;
+}
+
+// The scroll root's (#main-content) current scroll geometry.
+export interface SectionScrollMetrics {
+  scrollTop: number;
+  scrollHeight: number;
+  clientHeight: number;
 }
 
 export type EmailStatusFilter = (typeof EMAIL_STATUS_VALUES)[number];
diff --git a/tests/unit/section-nav.test.ts b/tests/unit/section-nav.test.ts
index fe60b1bd..ae1a13ac 100644
--- a/tests/unit/section-nav.test.ts
+++ b/tests/unit/section-nav.test.ts
@@ -65,57 +65,105 @@ describe('buildSectionNavItems', () => {
 });
 
 describe('selectActiveSectionId', () => {
-  it('picks the first intersecting entry in document order', () => {
+  const metrics = { scrollTop: 1200, scrollHeight: 3000, clientHeight: 800 };
+
+  it('returns null for an empty section list', () => {
+    expect(selectActiveSectionId([], metrics, null)).toBeNull();
+  });
+
+  it('ignores an edge-only overlap and picks the section below it', () => {
+    const sections = [
+      { id: 'a', top: 0 },
+      { id: 'b', top: 24 },
+    ];
+    expect(selectActiveSectionId(sections, metrics, null)).toBe('b');
+  });
+
+  it('picks the lower section once its top has crossed the reading line, even with the upper tail visible', () => {
+    const sections = [
+      { id: 'a', top: -500 },
+      { id: 'b', top: 300 },
+    ];
+    expect(selectActiveSectionId(sections, metrics, null)).toBe('b');
+  });
+
+  it('keeps the upper section while the lower section has not crossed the reading line', () => {
+    const sections = [
+      { id: 'a', top: -100 },
+      { id: 'b', top: 500 },
+    ];
+    expect(selectActiveSectionId(sections, metrics, null)).toBe('a');
+  });
+
+  it('picks the last section at the bottom of the page, even when its top is below the reading line', () => {
+    const sections = [
+      { id: 'a', top: -400 },
+      { id: 'b', top: 600 },
+    ];
     expect(
       selectActiveSectionId(
-        [
-          { id: 'a', isIntersecting: false },
-          { id: 'b', isIntersecting: true },
-          { id: 'c', isIntersecting: true },
-        ],
+        sections,
+        { scrollTop: 2200, scrollHeight: 3000, clientHeight: 800 },
         null,
       ),
     ).toBe('b');
   });
 
-  it('keeps the previous id when nothing intersects and it is still present', () => {
+  it('picks the first section at the top of the page, even when the second section is above the reading line', () => {
+    const sections = [
+      { id: 'a', top: 0 },
+      { id: 'b', top: -50 },
+    ];
     expect(
       selectActiveSectionId(
-        [
-          { id: 'a', isIntersecting: false },
-          { id: 'b', isIntersecting: false },
-        ],
-        'b',
+        sections,
+        { scrollTop: 0, scrollHeight: 3000, clientHeight: 800 },
+        null,
       ),
-    ).toBe('b');
+    ).toBe('a');
   });
 
-  it('falls back to the first entry when the previous id is gone', () => {
+  it('a pinned id beats the top, bottom and reading-line rules', () => {
+    const sections = [
+      { id: 'a', top: -400 },
+      { id: 'b', top: 600 },
+    ];
     expect(
       selectActiveSectionId(
-        [
-          { id: 'a', isIntersecting: false },
-          { id: 'b', isIntersecting: false },
-        ],
-        'z',
+        sections,
+        { scrollTop: 2200, scrollHeight: 3000, clientHeight: 800 },
+        'a',
       ),
     ).toBe('a');
   });
 
-  it('falls back to the first entry scrolled past the last section', () => {
+  it('ignores a pinned id that is not in the section list', () => {
+    const sections = [
+      { id: 'a', top: -100 },
+      { id: 'b', top: 500 },
+    ];
+    expect(selectActiveSectionId(sections, metrics, 'z')).toBe('a');
+  });
+
+  it('falls back to the first section when none has crossed the reading line', () => {
+    const sections = [
+      { id: 'a', top: 450 },
+      { id: 'b', top: 900 },
+    ];
+    expect(selectActiveSectionId(sections, metrics, null)).toBe('a');
+  });
+
+  it('returns the first section on a page that does not scroll', () => {
+    const sections = [
+      { id: 'a', top: 0 },
+      { id: 'b', top: 200 },
+    ];
     expect(
       selectActiveSectionId(
-        [
-          { id: 'a', isIntersecting: false },
-          { id: 'b', isIntersecting: false },
-          { id: 'c', isIntersecting: false },
-        ],
-        'c',
+        sections,
+        { scrollTop: 0, scrollHeight: 800, clientHeight: 800 },
+        null,
       ),
-    ).toBe('c');
-  });
-
-  it('returns null for an empty visibility list', () => {
-    expect(selectActiveSectionId([], 'a')).toBeNull();
+    ).toBe('a');
   });
 });

From 1fb601ef77b1fb25e03c8e851793b9150681c12f Mon Sep 17 00:00:00 2001
From: Ciel Bellerose <kcbellerose@icloud.com>
Date: Wed, 23 Sep 2026 20:46:19 -0400
Subject: [PATCH 13/35] #748 disable continue on past-deadline drafts, not hide
 it

MyApplicationPrimaryAction now gates draft the same way withdrawn was
already gated, and both degrade to a disabled Continue/Edit & resubmit
with an aria-describedby reason instead of a bare removal or note.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 .../my-application-primary-action.tsx         | 59 ++++++++++++------
 .../features/my-application-row-actions.tsx   |  2 +-
 components/features/my-applications-table.tsx |  2 +-
 docs/WORKFLOWS.md                             | 10 +--
 lib/constants.ts                              | 11 ++++
 lib/utils.ts                                  | 11 ++++
 tests/unit/utils.test.ts                      | 61 +++++++++++++++++++
 7 files changed, 131 insertions(+), 25 deletions(-)

diff --git a/components/features/my-application-primary-action.tsx b/components/features/my-application-primary-action.tsx
index 5b412986..c150bb2c 100644
--- a/components/features/my-application-primary-action.tsx
+++ b/components/features/my-application-primary-action.tsx
@@ -1,7 +1,8 @@
 import Link from 'next/link';
+import { useId } from 'react';
 
 import { type MyApplicationListItem } from '@/lib/types';
-import { isAcceptingApplications } from '@/lib/utils';
+import { getApplicantActionBlockedReason } from '@/lib/utils';
 
 import { Button } from '@/components/ui/button';
 
@@ -15,30 +16,52 @@ interface MyApplicationPrimaryActionProps {
 export function MyApplicationPrimaryAction({
   application,
 }: MyApplicationPrimaryActionProps) {
-  if (application.status === 'draft')
+  // Called unconditionally, before any early return (rules of hooks) — the
+  // table renders both the row and the mobile card for every application, so
+  // an id derived from application.id would be duplicated in the DOM.
+  const reasonId = useId();
+
+  if (application.status !== 'draft' && application.status !== 'withdrawn')
+    return null;
+
+  const isDraft = application.status === 'draft';
+  const label = isDraft ? 'Continue' : 'Edit & resubmit';
+  const ariaLabel = isDraft
+    ? `Continue application for ${application.position.title}`
+    : `Edit and resubmit application for ${application.position.title}`;
+  const reason = getApplicantActionBlockedReason(application.position);
+
+  if (reason === null)
     return (
       <Button variant="outline" size="sm" asChild>
-        <Link href={`/positions/${application.positionId}/apply`}>
-          Continue
+        <Link
+          href={`/positions/${application.positionId}/apply`}
+          aria-label={ariaLabel}
+        >
+          {label}
         </Link>
       </Button>
     );
 
-  if (application.status !== 'withdrawn') return null;
-
-  if (!isAcceptingApplications(application.position))
-    return (
-      <span className="text-muted-foreground text-sm">Position closed</span>
-    );
-
   return (
-    <Button variant="outline" size="sm" asChild>
-      <Link
-        href={`/positions/${application.positionId}/apply`}
-        aria-label={`Edit and resubmit application for ${application.position.title}`}
+    <span className="flex items-center gap-2">
+      <span
+        id={reasonId}
+        className="text-muted-foreground text-sm whitespace-nowrap"
       >
-        Edit &amp; resubmit
-      </Link>
-    </Button>
+        {reason}
+      </span>
+      <Button
+        type="button"
+        variant="outline"
+        size="sm"
+        aria-disabled="true"
+        aria-label={ariaLabel}
+        aria-describedby={reasonId}
+        className="aria-disabled:pointer-events-none aria-disabled:opacity-50"
+      >
+        {label}
+      </Button>
+    </span>
   );
 }
diff --git a/components/features/my-application-row-actions.tsx b/components/features/my-application-row-actions.tsx
index be90d861..aed1d50a 100644
--- a/components/features/my-application-row-actions.tsx
+++ b/components/features/my-application-row-actions.tsx
@@ -101,7 +101,7 @@ export function MyApplicationRowActions({
     );
   }
 
-  // withdrawn: the cell already carries the primary action (Edit & resubmit / Position closed).
+  // withdrawn: the primary action carries Edit & resubmit (or its disabled state).
   if (status === 'withdrawn') return null;
 
   // Desktop placeholder for these lives in the column cell, not here.
diff --git a/components/features/my-applications-table.tsx b/components/features/my-applications-table.tsx
index adb21e16..34f9cdcb 100644
--- a/components/features/my-applications-table.tsx
+++ b/components/features/my-applications-table.tsx
@@ -169,7 +169,7 @@ export function MyApplicationsTable({
                 'Draft'
               )}
             </span>
-            <div className="flex items-center gap-2">
+            <div className="flex flex-wrap items-center justify-end gap-2">
               <MyApplicationPrimaryAction application={app} />
               <MyApplicationRowActions
                 applicationId={app.id}
diff --git a/docs/WORKFLOWS.md b/docs/WORKFLOWS.md
index 57e4596a..9b769f76 100644
--- a/docs/WORKFLOWS.md
+++ b/docs/WORKFLOWS.md
@@ -308,13 +308,13 @@ Any signed-in user. Every user is an applicant; manager and admin capabilities a
 - **Trigger** — the My Applications nav item (`/applications`).
 - **Happy path** — `getMyApplications(user.id)` returns the caller's non-deleted applications on published positions, ordered by `submittedAt` (not `updatedAt` — [XC-8](#xc-8-applicant-facing-status-grouping)); a draft's `submittedAt` is null, and nulls sort first, so drafts cluster at the top of the default order. The table sorts client-side by position, status, applied date, or the new **Deadline** column, and collapses to stacked cards below `md`. Each row links to the detail page and carries its primary action and row action. Every status shown is the public one — `reached_out`/`interview_scheduled`/`reviewing` all read as **Applied**.
   - **Deadline column** — every row (draft, withdrawn, or submitted) shows `position.closesAt` via `DeadlineIndicator`, computed from `getDeadlineInfo` (`lib/utils.ts`) against a server-resolved `now` passed down as a prop, never a client-side `new Date()` (that would hydration-mismatch near a tier boundary). The **Deadline** column header already says what the date is, so the cell renders the bare date with no `Closes`/`Closed` prefix — except `upcoming`, which keeps its `Opens <date>` label since a bare date there would otherwise read as the deadline itself; a position with no `closesAt` shows the same neutral "—" the table already uses for missing values. A `past` deadline stays visually distinct from an upcoming one without the word: a `CalendarX` icon and `opacity-70` dimming ahead of the date, the same plain muted form for every status regardless of tier.
-  - **Urgency tiers (draft and withdrawn rows only)** — any future deadline renders bold `text-destructive-text` with the warning icon, regardless of distance: `distant` and `soon` show the bare date, `urgent` (≤ 24 hours) shows the compact countdown "Nh left" instead — the same format the widget uses, unified across both surfaces. There is no amber tier; `soon` is retained only to drive the at-risk float and the `N closing soon` count, not a distinct look. `past` (closed): the same plain muted bare date as any other status, no red — a draft's row still offers **Continue**, but a passed deadline is no longer flagged since there is nothing left to prompt.
+  - **Urgency tiers (draft and withdrawn rows only)** — any future deadline renders bold `text-destructive-text` with the warning icon, regardless of distance: `distant` and `soon` show the bare date, `urgent` (≤ 24 hours) shows the compact countdown "Nh left" instead — the same format the widget uses, unified across both surfaces. There is no amber tier; `soon` is retained only to drive the at-risk float and the `N closing soon` count, not a distinct look. `past` (closed): the same plain muted bare date as any other status, no red — the deadline column itself no longer flags it, since the Action column now carries the prompt (below).
   - **At-risk float** — drafts or withdrawn applications with an approaching deadline (tier `soon`/`urgent`) sort to the top, nearest deadline first; everything else keeps the table's normal order. Clicking any column header (including **Deadline**) takes over the sort completely — the float never reasserts itself afterward.
 - **Failure / edge**
   - Nothing yet → `EmptyState` "No applications yet" · "Browse open positions to start your first application." with a **Browse positions** button.
-  - A draft shows "—" for the applied date, **Continue** as its primary action and **Delete** as its row action.
+  - A draft shows "—" for the applied date, **Continue** as its primary action and **Delete** as its row action. On a position no longer accepting, **Continue** stays in place but is disabled, with the reason beside it (Deadline passed / Position closed / Not open yet, from `getApplicantActionBlockedReason`); **Delete** remains.
   - A deleted draft is never in this list — deleting one ([AP-15](#ap-15-delete-a-draft)) removes its row entirely; applying to the position again ([AP-5](#ap-5-start-an-application)) is the only way it reappears.
-  - A withdrawn row shows **Edit & resubmit**, or the plain text "Position closed" when the window has since closed; it has no row action, and its deadline tiers exactly as a draft's does.
+  - A withdrawn row shows **Edit & resubmit**, disabled with the same reason treatment once the window has closed; it has no row action, and its deadline tiers exactly as a draft's does.
   - `accepted` / `rejected` rows show "—" instead of a withdraw button.
   - Applications on soft-deleted or unpublished positions are excluded entirely.
   - A not-yet-open or past-due draft or withdrawn application never floats to the top — only an actually-open, approaching window counts as at-risk.
@@ -323,7 +323,7 @@ Any signed-in user. Every user is an applicant; manager and admin capabilities a
 ### AP-11 View one of your applications
 
 - **Trigger** — a position title link on `/applications`, or the redirect after submitting ([AP-9](#ap-9-submit-an-application)).
-- **Happy path** — `getMyApplication(id, user.id)` is scoped to the caller with the same visibility as the list, and returns the public status ([XC-8](#xc-8-applicant-facing-status-grouping)). The header shows the position title with the status badge directly beside it, the status sentence underneath, and the primary/row actions (Continue, Edit & resubmit, Withdraw, Delete draft — whichever applies) right-aligned on that same header row; below it, "Applied <date>" (or "Draft · last saved <date>", from `lastSavedAt` — a draft's own `updatedAt`, never exposed for a submitted application) and a link to the position, then both answer groups — "Your Profile Answers" and "Your Answers for This Position" — full width. The position-answers group lists **every** live position question, in the position's own question order, whether it was answered or not: an answered row renders from its snapshotted `questionLabel`/`value`/`type`, so a retyped or relabeled question still shows the original label and value; an unanswered one shows the current question's label with "No answer" in the value slot. An answer to a since-deleted question still renders, appended after the live questions.
+- **Happy path** — `getMyApplication(id, user.id)` is scoped to the caller with the same visibility as the list, and returns the public status ([XC-8](#xc-8-applicant-facing-status-grouping)). The header shows the position title with the status badge directly beside it, the status sentence underneath, and the primary/row actions (Continue, Edit & resubmit, Withdraw, Delete draft — whichever applies) right-aligned on that same header row; below it, "Applied <date>" (or "Draft · last saved <date>", from `lastSavedAt` — a draft's own `updatedAt`, never exposed for a submitted application) and a link to the position, then both answer groups — "Your Profile Answers" and "Your Answers for This Position" — full width. The position-answers group lists **every** live position question, in the position's own question order, whether it was answered or not: an answered row renders from its snapshotted `questionLabel`/`value`/`type`, so a retyped or relabeled question still shows the original label and value; an unanswered one shows the current question's label with "No answer" in the value slot. An answer to a since-deleted question still renders, appended after the live questions. The header's primary action follows the same rule as the list ([AP-10](#ap-10-track-your-applications)): on a draft or withdrawn application whose position is no longer accepting, Continue/Edit & resubmit is disabled with the reason beside it, and Delete/Withdraw still render alongside it.
   - **Deadline (drafts and withdrawn applications only)** — a fourth segment after the **View position** link, `DeadlineIndicator` (`variant="full"`, `emphasizeUrgency`) tiered against a server-resolved `now` — same helper and thresholds as [AP-10](#ap-10-track-your-applications). The gate is separate from the "Draft · last saved" vs "Applied" prefix above it, so a withdrawn application keeps its "Applied <date>" prefix while still gaining the deadline segment. A submitted or terminal application's meta line is unchanged; `getMyApplication`'s select already carries the fields needed, so no data-layer change.
 - **Failure / edge**
   - Not the caller's, soft-deleted, or on an unpublished position → `notFound()`, so a bookmarked URL cannot outlive its list row.
@@ -356,7 +356,7 @@ Any signed-in user. Every user is an applicant; manager and admin capabilities a
 - **Trigger** — **Edit & resubmit** on a withdrawn row in `/applications`, which returns to `/positions/[id]/apply`.
 - **Happy path** — `withdrawn` is applicant-editable, so the stepper reopens with every answer intact and editable, files included, above an info callout: "This application is withdrawn — It's out of the review queue, but reviewers can still see your answers — including edits you make here. Resubmit to put it back in the queue." Submitting runs [AP-9](#ap-9-submit-an-application) and toasts **"Application resubmitted"**.
 - **Failure / edge**
-  - The window closed while it was withdrawn → the row shows "Position closed" instead of the button, and the apply page renders "Applications are closed" ("This position stopped accepting applications, so this application can no longer be edited or submitted.").
+  - The window closed while it was withdrawn → the row shows **Edit & resubmit** disabled with its reason beside it, rather than the button; the apply page (if reached directly) renders "Applications are closed" ("This position stopped accepting applications, so this application can no longer be edited or submitted.").
   - Every [AP-9](#ap-9-submit-an-application) failure branch applies unchanged.
 - **End state** — status back to `applied` with a fresh `submittedAt` and a re-snapshotted `applicantName`. A second submission receipt emails, same as the first ([XC-9](#xc-9-applicant-email)).
 
diff --git a/lib/constants.ts b/lib/constants.ts
index 41f72d40..ff256e35 100644
--- a/lib/constants.ts
+++ b/lib/constants.ts
@@ -1038,6 +1038,17 @@ export const POSITION_AVAILABILITY_BADGE_VARIANT: Record<
   unavailable: 'outline',
 };
 
+// Reason shown beside a disabled Continue/Edit & resubmit — draft and
+// withdrawn share one gate, so the copy can't drift between them.
+export const APPLICANT_ACTION_BLOCKED_REASONS: Record<
+  Exclude<PositionAvailability, 'accepting'>,
+  string
+> = {
+  closed_by_date: 'Deadline passed',
+  unavailable: 'Position closed',
+  upcoming: 'Not open yet',
+};
+
 export const PRIVACY_HREF = '/privacy';
 export const TERMS_HREF = '/terms';
 
diff --git a/lib/utils.ts b/lib/utils.ts
index a3b0b553..4ba9a5dc 100644
--- a/lib/utils.ts
+++ b/lib/utils.ts
@@ -4,6 +4,7 @@ import { twMerge } from 'tailwind-merge';
 import type { $Enums } from '@/prisma/client';
 
 import {
+  APPLICANT_ACTION_BLOCKED_REASONS,
   APPLICATION_STATUS_LABELS,
   DEADLINE_SOON_DAYS,
   DEADLINE_URGENT_HOURS,
@@ -352,6 +353,16 @@ export function isOpenPastCloseDate(
   return getPositionAvailability(position, now) === 'closed_by_date';
 }
 
+/** `null` while accepting; otherwise the reason draft/withdrawn's Continue is disabled. */
+export function getApplicantActionBlockedReason(
+  position: PositionWindow,
+  now?: Date,
+): string | null {
+  const availability = getPositionAvailability(position, now);
+  if (availability === 'accepting') return null;
+  return APPLICANT_ACTION_BLOCKED_REASONS[availability];
+}
+
 export function getPositionDateInfo(
   position: PositionWindow,
   now: Date = new Date(),
diff --git a/tests/unit/utils.test.ts b/tests/unit/utils.test.ts
index 40f57241..7ba3b78f 100644
--- a/tests/unit/utils.test.ts
+++ b/tests/unit/utils.test.ts
@@ -22,6 +22,7 @@ import {
   formatCountdown,
   formatPaginationSummary,
   formatTableCount,
+  getApplicantActionBlockedReason,
   getApplicantName,
   getBulkDecisionEmailWarning,
   getDeadlineInfo,
@@ -105,6 +106,66 @@ describe('getPositionAvailability', () => {
   });
 });
 
+describe('getApplicantActionBlockedReason', () => {
+  it('is null when open with no window', () => {
+    expect(
+      getApplicantActionBlockedReason(
+        { status: 'open', opensAt: null, closesAt: null },
+        NOW,
+      ),
+    ).toBeNull();
+  });
+
+  it('is null at exactly closesAt (inclusive)', () => {
+    const closesAt = new Date(NOW);
+    expect(
+      getApplicantActionBlockedReason(
+        { status: 'open', opensAt: null, closesAt },
+        NOW,
+      ),
+    ).toBeNull();
+  });
+
+  it('is "Deadline passed" once now passes closesAt', () => {
+    const closesAt = new Date(NOW.getTime() - 1);
+    expect(
+      getApplicantActionBlockedReason(
+        { status: 'open', opensAt: null, closesAt },
+        NOW,
+      ),
+    ).toBe('Deadline passed');
+  });
+
+  it('is "Not open yet" while opensAt is in the future', () => {
+    const opensAt = new Date(NOW);
+    opensAt.setDate(opensAt.getDate() + 5);
+    expect(
+      getApplicantActionBlockedReason(
+        { status: 'open', opensAt, closesAt: null },
+        NOW,
+      ),
+    ).toBe('Not open yet');
+  });
+
+  it('is "Position closed" for status closed', () => {
+    expect(
+      getApplicantActionBlockedReason(
+        { status: 'closed', opensAt: null, closesAt: null },
+        NOW,
+      ),
+    ).toBe('Position closed');
+  });
+
+  it('is "Position closed" for status draft', () => {
+    expect(
+      getApplicantActionBlockedReason(
+        { status: 'draft', opensAt: null, closesAt: null },
+        NOW,
+      ),
+    ).toBe('Position closed');
+  });
+});
+
 describe('getPositionDateInfo', () => {
   it('reads Closes, calm, for a draft with a future close date', () => {
     const closesAt = new Date(NOW);

From 3ddedd2a11a459e0e061e7f1b5168c3cde0abe8a Mon Sep 17 00:00:00 2001
From: Ciel Bellerose <kcbellerose@icloud.com>
Date: Wed, 23 Sep 2026 20:52:52 -0400
Subject: [PATCH 14/35] #748 address review feedback

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 components/features/my-application-primary-action.tsx | 4 +---
 lib/utils.ts                                          | 2 +-
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/components/features/my-application-primary-action.tsx b/components/features/my-application-primary-action.tsx
index c150bb2c..91bc0e38 100644
--- a/components/features/my-application-primary-action.tsx
+++ b/components/features/my-application-primary-action.tsx
@@ -16,9 +16,7 @@ interface MyApplicationPrimaryActionProps {
 export function MyApplicationPrimaryAction({
   application,
 }: MyApplicationPrimaryActionProps) {
-  // Called unconditionally, before any early return (rules of hooks) — the
-  // table renders both the row and the mobile card for every application, so
-  // an id derived from application.id would be duplicated in the DOM.
+  // Unconditional before the early return (rules of hooks) — needed for both row and mobile-card renders.
   const reasonId = useId();
 
   if (application.status !== 'draft' && application.status !== 'withdrawn')
diff --git a/lib/utils.ts b/lib/utils.ts
index 4ba9a5dc..2edbaaa6 100644
--- a/lib/utils.ts
+++ b/lib/utils.ts
@@ -353,7 +353,7 @@ export function isOpenPastCloseDate(
   return getPositionAvailability(position, now) === 'closed_by_date';
 }
 
-/** `null` while accepting; otherwise the reason draft/withdrawn's Continue is disabled. */
+/** `null` while accepting; otherwise the reason the draft/withdrawn action is disabled. */
 export function getApplicantActionBlockedReason(
   position: PositionWindow,
   now?: Date,

From 490124809d71fd6ae344ecc4f5a4bb0a88dc2e55 Mon Sep 17 00:00:00 2001
From: Ciel Bellerose <kcbellerose@icloud.com>
Date: Thu, 24 Sep 2026 09:23:23 -0400
Subject: [PATCH 15/35] #748 address review feedback

Move the blocked-action reason from visible text into a shared
hover/focus tooltip (with an sr-only fallback for screen readers),
reused by both GatedActionButton and MyApplicationPrimaryAction so
the pattern can't drift between the two surfaces.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 .../features/disabled-action-tooltip.tsx      | 38 ++++++++++++++++++
 .../my-application-primary-action.tsx         | 39 ++++++++-----------
 components/features/my-applications-table.tsx |  2 +-
 .../position-status-header-actions.tsx        | 28 ++++++-------
 docs/WORKFLOWS.md                             |  8 ++--
 5 files changed, 71 insertions(+), 44 deletions(-)
 create mode 100644 components/features/disabled-action-tooltip.tsx

diff --git a/components/features/disabled-action-tooltip.tsx b/components/features/disabled-action-tooltip.tsx
new file mode 100644
index 00000000..9aa3eea9
--- /dev/null
+++ b/components/features/disabled-action-tooltip.tsx
@@ -0,0 +1,38 @@
+'use client';
+
+import { type ReactNode, useId } from 'react';
+
+import {
+  Tooltip,
+  TooltipContent,
+  TooltipProvider,
+  TooltipTrigger,
+} from '@/components/ui/tooltip';
+
+interface DisabledActionTooltipProps {
+  reason: string | null;
+  children: (describedBy: string | undefined) => ReactNode;
+}
+
+// Shared "disabled with reason" pattern: hover/focus tooltip plus a
+// persistent sr-only copy, since Radix unmounts closed tooltip content.
+export function DisabledActionTooltip({
+  reason,
+  children,
+}: DisabledActionTooltipProps) {
+  const reasonId = useId();
+
+  if (reason === null) return children(undefined);
+
+  return (
+    <TooltipProvider delayDuration={300}>
+      <Tooltip>
+        <TooltipTrigger asChild>{children(reasonId)}</TooltipTrigger>
+        <TooltipContent>{reason}</TooltipContent>
+      </Tooltip>
+      <span id={reasonId} className="sr-only">
+        {reason}
+      </span>
+    </TooltipProvider>
+  );
+}
diff --git a/components/features/my-application-primary-action.tsx b/components/features/my-application-primary-action.tsx
index 91bc0e38..db3c70e9 100644
--- a/components/features/my-application-primary-action.tsx
+++ b/components/features/my-application-primary-action.tsx
@@ -1,9 +1,9 @@
 import Link from 'next/link';
-import { useId } from 'react';
 
 import { type MyApplicationListItem } from '@/lib/types';
 import { getApplicantActionBlockedReason } from '@/lib/utils';
 
+import { DisabledActionTooltip } from '@/components/features/disabled-action-tooltip';
 import { Button } from '@/components/ui/button';
 
 interface MyApplicationPrimaryActionProps {
@@ -16,9 +16,6 @@ interface MyApplicationPrimaryActionProps {
 export function MyApplicationPrimaryAction({
   application,
 }: MyApplicationPrimaryActionProps) {
-  // Unconditional before the early return (rules of hooks) — needed for both row and mobile-card renders.
-  const reasonId = useId();
-
   if (application.status !== 'draft' && application.status !== 'withdrawn')
     return null;
 
@@ -42,24 +39,20 @@ export function MyApplicationPrimaryAction({
     );
 
   return (
-    <span className="flex items-center gap-2">
-      <span
-        id={reasonId}
-        className="text-muted-foreground text-sm whitespace-nowrap"
-      >
-        {reason}
-      </span>
-      <Button
-        type="button"
-        variant="outline"
-        size="sm"
-        aria-disabled="true"
-        aria-label={ariaLabel}
-        aria-describedby={reasonId}
-        className="aria-disabled:pointer-events-none aria-disabled:opacity-50"
-      >
-        {label}
-      </Button>
-    </span>
+    <DisabledActionTooltip reason={reason}>
+      {(describedBy) => (
+        <Button
+          type="button"
+          variant="outline"
+          size="sm"
+          aria-disabled="true"
+          aria-label={ariaLabel}
+          aria-describedby={describedBy}
+          className="aria-disabled:pointer-events-none aria-disabled:opacity-50"
+        >
+          {label}
+        </Button>
+      )}
+    </DisabledActionTooltip>
   );
 }
diff --git a/components/features/my-applications-table.tsx b/components/features/my-applications-table.tsx
index 34f9cdcb..adb21e16 100644
--- a/components/features/my-applications-table.tsx
+++ b/components/features/my-applications-table.tsx
@@ -169,7 +169,7 @@ export function MyApplicationsTable({
                 'Draft'
               )}
             </span>
-            <div className="flex flex-wrap items-center justify-end gap-2">
+            <div className="flex items-center gap-2">
               <MyApplicationPrimaryAction application={app} />
               <MyApplicationRowActions
                 applicationId={app.id}
diff --git a/components/features/position-status-header-actions.tsx b/components/features/position-status-header-actions.tsx
index b3795618..1c7c5f2c 100644
--- a/components/features/position-status-header-actions.tsx
+++ b/components/features/position-status-header-actions.tsx
@@ -17,6 +17,7 @@ import {
 import { ACTION_ICONS } from '@/lib/icons';
 import { isError } from '@/lib/utils';
 
+import { DisabledActionTooltip } from '@/components/features/disabled-action-tooltip';
 import { Button } from '@/components/ui/button';
 import { ConfirmDialog } from '@/components/ui/confirm-dialog';
 import {
@@ -25,12 +26,6 @@ import {
   DropdownMenuItem,
   DropdownMenuTrigger,
 } from '@/components/ui/dropdown-menu';
-import {
-  Tooltip,
-  TooltipContent,
-  TooltipProvider,
-  TooltipTrigger,
-} from '@/components/ui/tooltip';
 
 interface PositionStatusHeaderActionsProps {
   positionId: string;
@@ -69,17 +64,18 @@ function GatedActionButton({
     </Button>
   );
 
-  if (!disabledReason) return button;
-
   return (
-    <TooltipProvider delayDuration={300}>
-      <Tooltip>
-        <TooltipTrigger asChild>
-          <span tabIndex={0}>{button}</span>
-        </TooltipTrigger>
-        <TooltipContent>{disabledReason}</TooltipContent>
-      </Tooltip>
-    </TooltipProvider>
+    <DisabledActionTooltip reason={disabledReason}>
+      {(describedBy) =>
+        describedBy ? (
+          <span tabIndex={0} aria-describedby={describedBy}>
+            {button}
+          </span>
+        ) : (
+          button
+        )
+      }
+    </DisabledActionTooltip>
   );
 }
 
diff --git a/docs/WORKFLOWS.md b/docs/WORKFLOWS.md
index 9b769f76..b7be6441 100644
--- a/docs/WORKFLOWS.md
+++ b/docs/WORKFLOWS.md
@@ -312,9 +312,9 @@ Any signed-in user. Every user is an applicant; manager and admin capabilities a
   - **At-risk float** — drafts or withdrawn applications with an approaching deadline (tier `soon`/`urgent`) sort to the top, nearest deadline first; everything else keeps the table's normal order. Clicking any column header (including **Deadline**) takes over the sort completely — the float never reasserts itself afterward.
 - **Failure / edge**
   - Nothing yet → `EmptyState` "No applications yet" · "Browse open positions to start your first application." with a **Browse positions** button.
-  - A draft shows "—" for the applied date, **Continue** as its primary action and **Delete** as its row action. On a position no longer accepting, **Continue** stays in place but is disabled, with the reason beside it (Deadline passed / Position closed / Not open yet, from `getApplicantActionBlockedReason`); **Delete** remains.
+  - A draft shows "—" for the applied date, **Continue** as its primary action and **Delete** as its row action. On a position no longer accepting, **Continue** stays in place but is disabled, with the reason in a tooltip on hover/focus (Deadline passed / Position closed / Not open yet, from `getApplicantActionBlockedReason`); **Delete** remains.
   - A deleted draft is never in this list — deleting one ([AP-15](#ap-15-delete-a-draft)) removes its row entirely; applying to the position again ([AP-5](#ap-5-start-an-application)) is the only way it reappears.
-  - A withdrawn row shows **Edit & resubmit**, disabled with the same reason treatment once the window has closed; it has no row action, and its deadline tiers exactly as a draft's does.
+  - A withdrawn row shows **Edit & resubmit**, disabled with the same reason tooltip once the window has closed; it has no row action, and its deadline tiers exactly as a draft's does.
   - `accepted` / `rejected` rows show "—" instead of a withdraw button.
   - Applications on soft-deleted or unpublished positions are excluded entirely.
   - A not-yet-open or past-due draft or withdrawn application never floats to the top — only an actually-open, approaching window counts as at-risk.
@@ -323,7 +323,7 @@ Any signed-in user. Every user is an applicant; manager and admin capabilities a
 ### AP-11 View one of your applications
 
 - **Trigger** — a position title link on `/applications`, or the redirect after submitting ([AP-9](#ap-9-submit-an-application)).
-- **Happy path** — `getMyApplication(id, user.id)` is scoped to the caller with the same visibility as the list, and returns the public status ([XC-8](#xc-8-applicant-facing-status-grouping)). The header shows the position title with the status badge directly beside it, the status sentence underneath, and the primary/row actions (Continue, Edit & resubmit, Withdraw, Delete draft — whichever applies) right-aligned on that same header row; below it, "Applied <date>" (or "Draft · last saved <date>", from `lastSavedAt` — a draft's own `updatedAt`, never exposed for a submitted application) and a link to the position, then both answer groups — "Your Profile Answers" and "Your Answers for This Position" — full width. The position-answers group lists **every** live position question, in the position's own question order, whether it was answered or not: an answered row renders from its snapshotted `questionLabel`/`value`/`type`, so a retyped or relabeled question still shows the original label and value; an unanswered one shows the current question's label with "No answer" in the value slot. An answer to a since-deleted question still renders, appended after the live questions. The header's primary action follows the same rule as the list ([AP-10](#ap-10-track-your-applications)): on a draft or withdrawn application whose position is no longer accepting, Continue/Edit & resubmit is disabled with the reason beside it, and Delete/Withdraw still render alongside it.
+- **Happy path** — `getMyApplication(id, user.id)` is scoped to the caller with the same visibility as the list, and returns the public status ([XC-8](#xc-8-applicant-facing-status-grouping)). The header shows the position title with the status badge directly beside it, the status sentence underneath, and the primary/row actions (Continue, Edit & resubmit, Withdraw, Delete draft — whichever applies) right-aligned on that same header row; below it, "Applied <date>" (or "Draft · last saved <date>", from `lastSavedAt` — a draft's own `updatedAt`, never exposed for a submitted application) and a link to the position, then both answer groups — "Your Profile Answers" and "Your Answers for This Position" — full width. The position-answers group lists **every** live position question, in the position's own question order, whether it was answered or not: an answered row renders from its snapshotted `questionLabel`/`value`/`type`, so a retyped or relabeled question still shows the original label and value; an unanswered one shows the current question's label with "No answer" in the value slot. An answer to a since-deleted question still renders, appended after the live questions. The header's primary action follows the same rule as the list ([AP-10](#ap-10-track-your-applications)): on a draft or withdrawn application whose position is no longer accepting, Continue/Edit & resubmit is disabled with the reason in a tooltip on hover/focus, and Delete/Withdraw still render alongside it.
   - **Deadline (drafts and withdrawn applications only)** — a fourth segment after the **View position** link, `DeadlineIndicator` (`variant="full"`, `emphasizeUrgency`) tiered against a server-resolved `now` — same helper and thresholds as [AP-10](#ap-10-track-your-applications). The gate is separate from the "Draft · last saved" vs "Applied" prefix above it, so a withdrawn application keeps its "Applied <date>" prefix while still gaining the deadline segment. A submitted or terminal application's meta line is unchanged; `getMyApplication`'s select already carries the fields needed, so no data-layer change.
 - **Failure / edge**
   - Not the caller's, soft-deleted, or on an unpublished position → `notFound()`, so a bookmarked URL cannot outlive its list row.
@@ -356,7 +356,7 @@ Any signed-in user. Every user is an applicant; manager and admin capabilities a
 - **Trigger** — **Edit & resubmit** on a withdrawn row in `/applications`, which returns to `/positions/[id]/apply`.
 - **Happy path** — `withdrawn` is applicant-editable, so the stepper reopens with every answer intact and editable, files included, above an info callout: "This application is withdrawn — It's out of the review queue, but reviewers can still see your answers — including edits you make here. Resubmit to put it back in the queue." Submitting runs [AP-9](#ap-9-submit-an-application) and toasts **"Application resubmitted"**.
 - **Failure / edge**
-  - The window closed while it was withdrawn → the row shows **Edit & resubmit** disabled with its reason beside it, rather than the button; the apply page (if reached directly) renders "Applications are closed" ("This position stopped accepting applications, so this application can no longer be edited or submitted.").
+  - The window closed while it was withdrawn → the row shows **Edit & resubmit** disabled with its reason in a tooltip, rather than the button; the apply page (if reached directly) renders "Applications are closed" ("This position stopped accepting applications, so this application can no longer be edited or submitted.").
   - Every [AP-9](#ap-9-submit-an-application) failure branch applies unchanged.
 - **End state** — status back to `applied` with a fresh `submittedAt` and a re-snapshotted `applicantName`. A second submission receipt emails, same as the first ([XC-9](#xc-9-applicant-email)).
 

From 0b2151da36ed06f2d3300600657888cd0eb9dcb5 Mon Sep 17 00:00:00 2001
From: Ciel Bellerose <kcbellerose@icloud.com>
Date: Thu, 24 Sep 2026 12:14:21 -0400
Subject: [PATCH 16/35] #748 fix detail-page crash and tooltip hover on
 disabled action

DisabledActionTooltip took a render-prop function as children, which
crashes when a server component (the applications detail page) renders
it. Switched to a plain element the component clones internally; it now
also owns the pointer-events wrapper so hover opens the tooltip when the
inner control has pointer-events:none.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 .../features/disabled-action-tooltip.tsx      | 26 ++++++++++++---
 .../my-application-primary-action.tsx         | 23 ++++++-------
 .../position-status-header-actions.tsx        | 32 ++++++-------------
 3 files changed, 42 insertions(+), 39 deletions(-)

diff --git a/components/features/disabled-action-tooltip.tsx b/components/features/disabled-action-tooltip.tsx
index 9aa3eea9..12f0ef28 100644
--- a/components/features/disabled-action-tooltip.tsx
+++ b/components/features/disabled-action-tooltip.tsx
@@ -1,6 +1,6 @@
 'use client';
 
-import { type ReactNode, useId } from 'react';
+import { type ReactElement, cloneElement, useId } from 'react';
 
 import {
   Tooltip,
@@ -11,23 +11,41 @@ import {
 
 interface DisabledActionTooltipProps {
   reason: string | null;
-  children: (describedBy: string | undefined) => ReactNode;
+  children: ReactElement<{ disabled?: boolean; 'aria-describedby'?: string }>;
 }
 
 // Shared "disabled with reason" pattern: hover/focus tooltip plus a
 // persistent sr-only copy, since Radix unmounts closed tooltip content.
+// A plain element (never a function) so a server component can pass this
+// through props without crossing a function across the RSC boundary.
+// Wraps in a span so hover still reaches the trigger even when the child
+// itself has pointer-events:none (aria-disabled). A natively `disabled`
+// child can't take focus, so the span becomes the tab stop and description
+// target instead; an aria-disabled child keeps its own focus and describedby.
 export function DisabledActionTooltip({
   reason,
   children,
 }: DisabledActionTooltipProps) {
   const reasonId = useId();
 
-  if (reason === null) return children(undefined);
+  if (reason === null) return children;
+
+  const childTakesFocus = !children.props.disabled;
+  const trigger = childTakesFocus
+    ? cloneElement(children, { 'aria-describedby': reasonId })
+    : children;
 
   return (
     <TooltipProvider delayDuration={300}>
       <Tooltip>
-        <TooltipTrigger asChild>{children(reasonId)}</TooltipTrigger>
+        <TooltipTrigger asChild>
+          <span
+            tabIndex={childTakesFocus ? undefined : 0}
+            aria-describedby={childTakesFocus ? undefined : reasonId}
+          >
+            {trigger}
+          </span>
+        </TooltipTrigger>
         <TooltipContent>{reason}</TooltipContent>
       </Tooltip>
       <span id={reasonId} className="sr-only">
diff --git a/components/features/my-application-primary-action.tsx b/components/features/my-application-primary-action.tsx
index db3c70e9..7d8b9523 100644
--- a/components/features/my-application-primary-action.tsx
+++ b/components/features/my-application-primary-action.tsx
@@ -40,19 +40,16 @@ export function MyApplicationPrimaryAction({
 
   return (
     <DisabledActionTooltip reason={reason}>
-      {(describedBy) => (
-        <Button
-          type="button"
-          variant="outline"
-          size="sm"
-          aria-disabled="true"
-          aria-label={ariaLabel}
-          aria-describedby={describedBy}
-          className="aria-disabled:pointer-events-none aria-disabled:opacity-50"
-        >
-          {label}
-        </Button>
-      )}
+      <Button
+        type="button"
+        variant="outline"
+        size="sm"
+        aria-disabled="true"
+        aria-label={ariaLabel}
+        className="aria-disabled:pointer-events-none aria-disabled:opacity-50"
+      >
+        {label}
+      </Button>
     </DisabledActionTooltip>
   );
 }
diff --git a/components/features/position-status-header-actions.tsx b/components/features/position-status-header-actions.tsx
index 1c7c5f2c..c2385261 100644
--- a/components/features/position-status-header-actions.tsx
+++ b/components/features/position-status-header-actions.tsx
@@ -51,30 +51,18 @@ function GatedActionButton({
   pending: boolean;
   onClick: () => void;
 }) {
-  const button = (
-    <Button
-      variant="default"
-      size="sm"
-      className="min-h-11 sm:min-h-9"
-      disabled={disabled}
-      onClick={onClick}
-    >
-      {pending && <ACTION_ICONS.pending className="animate-spin" />}
-      {label}
-    </Button>
-  );
-
   return (
     <DisabledActionTooltip reason={disabledReason}>
-      {(describedBy) =>
-        describedBy ? (
-          <span tabIndex={0} aria-describedby={describedBy}>
-            {button}
-          </span>
-        ) : (
-          button
-        )
-      }
+      <Button
+        variant="default"
+        size="sm"
+        className="min-h-11 sm:min-h-9"
+        disabled={disabled}
+        onClick={onClick}
+      >
+        {pending && <ACTION_ICONS.pending className="animate-spin" />}
+        {label}
+      </Button>
     </DisabledActionTooltip>
   );
 }

From 4502e69e03dfede3b763307e41d68751f0e4fbed Mon Sep 17 00:00:00 2001
From: Ciel Bellerose <kcbellerose@icloud.com>
Date: Thu, 24 Sep 2026 15:08:07 -0400
Subject: [PATCH 17/35] #772 animate tooltips in as well as out

Radix Tooltip never sets data-state="open" on TooltipContent (its
open states are delayed-open/instant-open), so the gated enter
classes never matched. Make the enter animation unconditional.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 components/ui/tooltip.tsx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/components/ui/tooltip.tsx b/components/ui/tooltip.tsx
index 04ee20b2..7db60e6c 100644
--- a/components/ui/tooltip.tsx
+++ b/components/ui/tooltip.tsx
@@ -35,7 +35,7 @@ function TooltipContent({
         data-slot="tooltip-content"
         sideOffset={sideOffset}
         className={cn(
-          'bg-popover text-popover-foreground data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-50 max-w-xs origin-(--radix-tooltip-content-transform-origin) overflow-hidden rounded-md border px-3 py-1.5 text-sm shadow-md',
+          'bg-popover text-popover-foreground animate-in fade-in-0 zoom-in-95 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-50 max-w-xs origin-(--radix-tooltip-content-transform-origin) overflow-hidden rounded-md border px-3 py-1.5 text-sm shadow-md',
           className,
         )}
         {...props}

From 880d75ef0457082035958424b27e9a520c7e5940 Mon Sep 17 00:00:00 2001
From: Ciel Bellerose <kcbellerose@icloud.com>
Date: Thu, 24 Sep 2026 11:17:53 -0400
Subject: [PATCH 18/35] #617 move recent activity into a global activity panel

Relocates the dashboard "Recent activity" card into a Sheet reachable
from every authenticated page (sidebar on desktop, mobile-nav on
mobile), so activity isn't tied to standing on the dashboard.
getActivityGroups composes the caller's own applications with a
reviewer group scoped to managed/all positions, self-filtered so a
reviewer's own application never appears twice.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 components/features/activity-feed.tsx     | 204 ++++++++++------------
 components/features/activity-panel.tsx    |  41 +++++
 components/features/admin-dashboard.tsx   |   9 -
 components/features/manager-dashboard.tsx |   9 -
 components/features/user-dashboard.tsx    |   9 -
 components/layouts/app-shell.tsx          |  27 ++-
 components/layouts/mobile-nav.tsx         |   7 +-
 components/layouts/sidebar.tsx            |   4 +
 components/ui/section-card.tsx            |   9 -
 docs/WORKFLOWS.md                         |  19 +-
 lib/constants.ts                          |  41 ++++-
 lib/types.ts                              |  11 ++
 prisma/data/activity.ts                   |  64 +++++++
 tests/db/authorization.test.ts            | 100 +++++++++++
 14 files changed, 401 insertions(+), 153 deletions(-)
 create mode 100644 components/features/activity-panel.tsx
 create mode 100644 prisma/data/activity.ts

diff --git a/components/features/activity-feed.tsx b/components/features/activity-feed.tsx
index 74fd0a58..25c62949 100644
--- a/components/features/activity-feed.tsx
+++ b/components/features/activity-feed.tsx
@@ -1,134 +1,122 @@
-import {
-  getMyRecentActivity,
-  getRecentApplications,
-} from '@/prisma/data/applications';
+import { getActivityGroups } from '@/prisma/data/activity';
 
 import {
-  APPLICATION_STATUS_BADGE_VARIANT,
-  APPLICATION_STATUS_LABELS,
+  ACTIVITY_FEED_COPY,
+  ACTIVITY_MINE_TITLE,
   STATUS_BADGE_VARIANT_TO_DOT,
 } from '@/lib/constants';
 import { CONCEPT_ICONS } from '@/lib/icons';
-import { type ActivityItem, type Reviewer } from '@/lib/types';
-import { getDisplayName, getRenamedTo } from '@/lib/utils';
+import { type ActivityItem } from '@/lib/types';
 
 import { LocalTime } from '@/components/ui/local-time';
-import { SectionCard, SectionCardEmpty } from '@/components/ui/section-card';
-
-// ─── Presentational leaf ─────────────────────────────────────────────────────
+import { SectionCardEmpty } from '@/components/ui/section-card';
+import { Skeleton } from '@/components/ui/skeleton';
 
-interface ActivityFeedListProps {
-  items: ActivityItem[];
-  emptyDescription: string;
+export function ActivityFeedList({ items }: { items: ActivityItem[] }) {
+  return (
+    <ol>
+      {items.map((item) => {
+        const dotClass = STATUS_BADGE_VARIANT_TO_DOT[item.statusVariant];
+
+        return (
+          <li
+            key={item.id}
+            className="flex items-start gap-3 border-b px-4 py-3 last:border-0"
+          >
+            <span
+              className={`mt-1.5 size-2 shrink-0 rounded-full ${dotClass}`}
+              aria-hidden="true"
+            />
+            <p className="line-clamp-2 min-w-0 flex-1 text-sm">
+              {item.sentence}
+            </p>
+            <LocalTime
+              date={item.timestamp}
+              precision="relative"
+              className="text-muted-foreground ml-auto shrink-0 text-xs tabular-nums"
+            />
+          </li>
+        );
+      })}
+    </ol>
+  );
 }
 
-function ActivityFeedList({ items, emptyDescription }: ActivityFeedListProps) {
+function ActivityFeedGroup({
+  id,
+  title,
+  items,
+}: {
+  id: string;
+  title: string;
+  items: ActivityItem[];
+}) {
   return (
-    <SectionCard
-      title="Recent Activity"
-      icon={CONCEPT_ICONS.activity}
-      sectionLabel="Recent activity"
-    >
-      {items.length === 0 ? (
-        <SectionCardEmpty
-          icon={CONCEPT_ICONS.activity}
-          title="No recent activity"
-          description={emptyDescription}
-        />
-      ) : (
-        <ol>
-          {items.map((item) => {
-            const dotClass = STATUS_BADGE_VARIANT_TO_DOT[item.statusVariant];
-
-            return (
-              <li
-                key={item.id}
-                className="flex items-start gap-3 border-b px-4 py-3 last:border-0"
-              >
-                <span
-                  className={`mt-1.5 size-2 shrink-0 rounded-full ${dotClass}`}
-                  aria-hidden="true"
-                />
-                <p className="line-clamp-2 min-w-0 flex-1 text-sm">
-                  {item.sentence}
-                </p>
-                <LocalTime
-                  date={item.timestamp}
-                  precision="relative"
-                  className="text-muted-foreground ml-auto shrink-0 text-xs tabular-nums"
-                />
-              </li>
-            );
-          })}
-        </ol>
-      )}
-    </SectionCard>
+    <section aria-labelledby={id}>
+      <h3
+        id={id}
+        className="text-muted-foreground px-4 pt-4 pb-1 text-xs font-medium"
+      >
+        {title}
+      </h3>
+      <ActivityFeedList items={items} />
+    </section>
   );
 }
 
-// ─── Applicant feed wrapper ───────────────────────────────────────────────────
-
-interface ApplicantActivityFeedProps {
+interface ActivityFeedProps {
   userId: string;
+  isAdmin: boolean;
 }
 
-// States the current status only — no status-history table, so no from-state to assert.
-export async function ApplicantActivityFeed({
-  userId,
-}: ApplicantActivityFeedProps) {
-  const applications = await getMyRecentActivity(userId, 10);
+export async function ActivityFeed({ userId, isAdmin }: ActivityFeedProps) {
+  const { scope, mine, reviewed } = await getActivityGroups(userId, isAdmin);
+  const copy = ACTIVITY_FEED_COPY[scope];
 
-  const items: ActivityItem[] = applications.map((app) => {
-    const statusLabel = APPLICATION_STATUS_LABELS[app.status];
-    const variant = APPLICATION_STATUS_BADGE_VARIANT[app.status];
-    return {
-      id: app.id,
-      statusVariant: variant,
-      sentence: `Your application for ${app.position.title} is ${statusLabel}`,
-      timestamp: app.submittedAt,
-    };
-  });
+  if (mine.length === 0 && reviewed.length === 0)
+    return (
+      <SectionCardEmpty
+        icon={CONCEPT_ICONS.activity}
+        title="No recent activity"
+        description={copy.emptyDescription}
+      />
+    );
+
+  if (scope === 'none') return <ActivityFeedList items={mine} />;
 
   return (
-    <ActivityFeedList
-      items={items}
-      emptyDescription="Updates to your applications will show up here."
-    />
+    <>
+      {mine.length > 0 && (
+        <ActivityFeedGroup
+          id="activity-mine"
+          title={ACTIVITY_MINE_TITLE}
+          items={mine}
+        />
+      )}
+      {reviewed.length > 0 && copy.reviewedTitle && (
+        <ActivityFeedGroup
+          id="activity-reviewed"
+          title={copy.reviewedTitle}
+          items={reviewed}
+        />
+      )}
+    </>
   );
 }
 
-// ─── Reviewer feed wrapper ─────────────────────────────────────────────────────
-
-interface ReviewerActivityFeedProps {
-  reviewer: Reviewer;
-}
-
-// Ordered by submittedAt (a provable event stream); cross-user data, reviewer-gated only.
-export async function ReviewerActivityFeed({
-  reviewer,
-}: ReviewerActivityFeedProps) {
-  const applications = await getRecentApplications(reviewer, 10);
-
-  const items: ActivityItem[] = applications.map((app) => {
-    const applicantLabel = getDisplayName(app);
-    const renamedTo = getRenamedTo(app);
-    const variant = APPLICATION_STATUS_BADGE_VARIANT[app.status];
-    return {
-      id: app.id,
-      statusVariant: variant,
-      sentence: `${applicantLabel}${renamedTo ? ` (${renamedTo})` : ''} applied for ${app.position.title}`,
-      timestamp: app.submittedAt,
-    };
-  });
-
+export function ActivityFeedListSkeleton() {
   return (
-    <ActivityFeedList
-      items={items}
-      emptyDescription={
-        reviewer.isAdmin
-          ? 'New applications across all positions will show up here.'
-          : 'New applications to the positions you manage will show up here.'
-      }
-    />
+    <ol>
+      {Array.from({ length: 10 }).map((_, i) => (
+        <li
+          key={i}
+          className="flex items-center gap-3 border-b px-4 py-3 last:border-0"
+        >
+          <Skeleton className="size-2 shrink-0 rounded-full" />
+          <Skeleton className="h-4 flex-1" />
+          <Skeleton className="h-3 w-12" />
+        </li>
+      ))}
+    </ol>
   );
 }
diff --git a/components/features/activity-panel.tsx b/components/features/activity-panel.tsx
new file mode 100644
index 00000000..b3b94612
--- /dev/null
+++ b/components/features/activity-panel.tsx
@@ -0,0 +1,41 @@
+'use client';
+
+import { type ReactNode, useState } from 'react';
+
+import { CONCEPT_ICONS } from '@/lib/icons';
+
+import { Button } from '@/components/ui/button';
+import {
+  Sheet,
+  SheetContent,
+  SheetDescription,
+  SheetTitle,
+  SheetTrigger,
+} from '@/components/ui/sheet';
+
+interface ActivityPanelProps {
+  description: string;
+  children: ReactNode;
+}
+
+export function ActivityPanel({ description, children }: ActivityPanelProps) {
+  const [open, setOpen] = useState(false);
+  const ActivityIcon = CONCEPT_ICONS.activity;
+
+  return (
+    <Sheet open={open} onOpenChange={setOpen}>
+      <SheetTrigger asChild>
+        <Button variant="ghost" size="icon" aria-label="Open recent activity">
+          <ActivityIcon className="size-5" />
+        </Button>
+      </SheetTrigger>
+      <SheetContent side="right" className="flex flex-col gap-0 p-0">
+        <div className="border-b px-4 py-3 pr-12">
+          <SheetTitle className="text-base">Recent activity</SheetTitle>
+          <SheetDescription>{description}</SheetDescription>
+        </div>
+        <div className="min-h-0 flex-1 overflow-y-auto">{children}</div>
+      </SheetContent>
+    </Sheet>
+  );
+}
diff --git a/components/features/admin-dashboard.tsx b/components/features/admin-dashboard.tsx
index 3f567135..d79e93b6 100644
--- a/components/features/admin-dashboard.tsx
+++ b/components/features/admin-dashboard.tsx
@@ -2,7 +2,6 @@ import { Suspense } from 'react';
 
 import { type Reviewer } from '@/lib/types';
 
-import { ReviewerActivityFeed } from '@/components/features/activity-feed';
 import { OpenPositionsSummary } from '@/components/features/open-positions-summary';
 import {
   PipelineSummary,
@@ -36,14 +35,6 @@ export function AdminDashboard({ reviewer }: AdminDashboardProps) {
       <Suspense fallback={<SectionCardSkeleton rowShape="meta" />}>
         <OpenPositionsSummary take={3} />
       </Suspense>
-
-      <Suspense
-        fallback={
-          <SectionCardSkeleton rowShape="timeline" rows={10} hasLink={false} />
-        }
-      >
-        <ReviewerActivityFeed reviewer={reviewer} />
-      </Suspense>
     </div>
   );
 }
diff --git a/components/features/manager-dashboard.tsx b/components/features/manager-dashboard.tsx
index 7e734df3..fb84f0a6 100644
--- a/components/features/manager-dashboard.tsx
+++ b/components/features/manager-dashboard.tsx
@@ -2,7 +2,6 @@ import { Suspense } from 'react';
 
 import { type Reviewer } from '@/lib/types';
 
-import { ReviewerActivityFeed } from '@/components/features/activity-feed';
 import {
   ManagedPositionsWidget,
   ManagedPositionsWidgetSkeleton,
@@ -41,14 +40,6 @@ export function ManagerDashboard({ user }: ManagerDashboardProps) {
         <ManagedPositionsWidget userId={user.id} take={3} />
       </Suspense>
 
-      <Suspense
-        fallback={
-          <SectionCardSkeleton rowShape="timeline" rows={10} hasLink={false} />
-        }
-      >
-        <ReviewerActivityFeed reviewer={user} />
-      </Suspense>
-
       <Suspense
         fallback={<SectionCardSkeleton rowShape="badge-meta" hasSubtitle />}
       >
diff --git a/components/features/user-dashboard.tsx b/components/features/user-dashboard.tsx
index 38ccb3a1..e5264235 100644
--- a/components/features/user-dashboard.tsx
+++ b/components/features/user-dashboard.tsx
@@ -2,7 +2,6 @@ import { Suspense } from 'react';
 
 import { getFirstName } from '@/lib/utils';
 
-import { ApplicantActivityFeed } from '@/components/features/activity-feed';
 import {
   ApplicantSummary,
   ApplicantSummarySkeleton,
@@ -48,14 +47,6 @@ export function UserDashboard({ userId, userName }: UserDashboardProps) {
       <Suspense fallback={<SectionCardSkeleton rowShape="stacked-action" />}>
         <OpenPositionsWidget limit={3} />
       </Suspense>
-
-      <Suspense
-        fallback={
-          <SectionCardSkeleton rowShape="timeline" rows={10} hasLink={false} />
-        }
-      >
-        <ApplicantActivityFeed userId={userId} />
-      </Suspense>
     </div>
   );
 }
diff --git a/components/layouts/app-shell.tsx b/components/layouts/app-shell.tsx
index a7810059..75378c87 100644
--- a/components/layouts/app-shell.tsx
+++ b/components/layouts/app-shell.tsx
@@ -1,10 +1,16 @@
-import type { ReactNode } from 'react';
+import { type ReactNode, Suspense } from 'react';
 
 import { isManager } from '@/prisma/data/managers';
 
 import { getIsBypass, getOptionalUser } from '@/lib/auth/server';
-import type { NavIdentity } from '@/lib/types';
+import { ACTIVITY_FEED_COPY } from '@/lib/constants';
+import type { ActivityScope, NavIdentity } from '@/lib/types';
 
+import {
+  ActivityFeed,
+  ActivityFeedListSkeleton,
+} from '@/components/features/activity-feed';
+import { ActivityPanel } from '@/components/features/activity-panel';
 import { AppFooter } from '@/components/layouts/app-footer';
 import { MobileNav } from '@/components/layouts/mobile-nav';
 import { Sidebar } from '@/components/layouts/sidebar';
@@ -15,6 +21,7 @@ export async function AppShell({ children }: { children: ReactNode }) {
   let identity: NavIdentity | null = null;
   let isAdmin = false;
   let canReviewApplications = false;
+  let activityPanel: ReactNode = null;
 
   if (user) {
     // Admins always see reviewer nav, so manager status matters only for the rest.
@@ -32,6 +39,20 @@ export async function AppShell({ children }: { children: ReactNode }) {
         : 'User';
 
     identity = { name: user.name, email: user.email, roleLabel, isBypass };
+
+    const scope: ActivityScope = user.isAdmin
+      ? 'all'
+      : userIsManager
+        ? 'managed'
+        : 'none';
+
+    activityPanel = (
+      <ActivityPanel description={ACTIVITY_FEED_COPY[scope].description}>
+        <Suspense fallback={<ActivityFeedListSkeleton />}>
+          <ActivityFeed userId={user.id} isAdmin={user.isAdmin} />
+        </Suspense>
+      </ActivityPanel>
+    );
   }
 
   return (
@@ -40,12 +61,14 @@ export async function AppShell({ children }: { children: ReactNode }) {
         isAdmin={isAdmin}
         identity={identity}
         canReviewApplications={canReviewApplications}
+        activityPanel={activityPanel}
       />
       <div className="flex flex-1 flex-col overflow-hidden">
         <MobileNav
           isAdmin={isAdmin}
           identity={identity}
           canReviewApplications={canReviewApplications}
+          activityPanel={activityPanel}
         />
         <main
           id="main-content"
diff --git a/components/layouts/mobile-nav.tsx b/components/layouts/mobile-nav.tsx
index 1bf20c87..f1517f01 100644
--- a/components/layouts/mobile-nav.tsx
+++ b/components/layouts/mobile-nav.tsx
@@ -1,7 +1,7 @@
 'use client';
 
 import Link from 'next/link';
-import { useState } from 'react';
+import { type ReactNode, useState } from 'react';
 
 import { Menu } from 'lucide-react';
 
@@ -23,12 +23,14 @@ interface MobileNavProps {
   isAdmin: boolean;
   identity: NavIdentity | null;
   canReviewApplications: boolean;
+  activityPanel?: ReactNode;
 }
 
 export function MobileNav({
   isAdmin,
   identity,
   canReviewApplications,
+  activityPanel,
 }: MobileNavProps) {
   const [open, setOpen] = useState(false);
   const { topLevelItems, groups, logoHref, isActive } = useNavItems({
@@ -51,7 +53,8 @@ export function MobileNav({
         </span>
       </Link>
 
-      <div className="ml-auto">
+      <div className="ml-auto flex items-center gap-1">
+        {activityPanel}
         <Sheet open={open} onOpenChange={setOpen}>
           <SheetTrigger asChild>
             <Button variant="ghost" size="icon" aria-label="Open menu">
diff --git a/components/layouts/sidebar.tsx b/components/layouts/sidebar.tsx
index 7970d0d5..d5785410 100644
--- a/components/layouts/sidebar.tsx
+++ b/components/layouts/sidebar.tsx
@@ -1,6 +1,7 @@
 'use client';
 
 import Link from 'next/link';
+import type { ReactNode } from 'react';
 
 import type { NavIdentity } from '@/lib/types';
 
@@ -14,12 +15,14 @@ interface SidebarProps {
   isAdmin: boolean;
   identity: NavIdentity | null;
   canReviewApplications: boolean;
+  activityPanel?: ReactNode;
 }
 
 export function Sidebar({
   isAdmin,
   identity,
   canReviewApplications,
+  activityPanel,
 }: SidebarProps) {
   const { topLevelItems, groups, logoHref, isActive } = useNavItems({
     identity,
@@ -41,6 +44,7 @@ export function Sidebar({
             )}
           </span>
         </Link>
+        {activityPanel && <div className="ml-auto">{activityPanel}</div>}
       </div>
 
       <NavList
diff --git a/components/ui/section-card.tsx b/components/ui/section-card.tsx
index f126d50a..48307c1d 100644
--- a/components/ui/section-card.tsx
+++ b/components/ui/section-card.tsx
@@ -123,7 +123,6 @@ type SectionCardSkeletonRowShape =
   | 'meta'
   | 'badge-meta'
   | 'stacked-action'
-  | 'timeline'
   | 'badge-stacked'
   | 'form-field';
 
@@ -200,14 +199,6 @@ function SectionCardSkeletonRow({
           </div>
         </div>
       );
-    case 'timeline':
-      return (
-        <div className="flex items-center gap-3 border-b px-4 py-3 last:border-0">
-          <Skeleton className="size-2 shrink-0 rounded-full" />
-          <Skeleton className="h-4 flex-1" />
-          <Skeleton className="h-3 w-12" />
-        </div>
-      );
     case 'badge-stacked':
       return (
         <div className="border-b px-4 py-3 last:border-0">
diff --git a/docs/WORKFLOWS.md b/docs/WORKFLOWS.md
index b7be6441..80d3c91a 100644
--- a/docs/WORKFLOWS.md
+++ b/docs/WORKFLOWS.md
@@ -21,7 +21,7 @@ Behaviour shared by many workflows is stated once under [Cross-cutting behaviour
 
 ## Table of contents
 
-**[Cross-cutting behaviours](#cross-cutting-behaviours)** — [XC-1](#xc-1-sign-in-gate-and-the-redirectto-round-trip) · [XC-2](#xc-2-name-gate) · [XC-3](#xc-3-profile-completeness) · [XC-4](#xc-4-denial-shape) · [XC-5](#xc-5-errors-and-feedback) · [XC-6](#xc-6-rate-limiting) · [XC-7](#xc-7-deactivated-account) · [XC-8](#xc-8-applicant-facing-status-grouping) · [XC-9](#xc-9-applicant-email)
+**[Cross-cutting behaviours](#cross-cutting-behaviours)** — [XC-1](#xc-1-sign-in-gate-and-the-redirectto-round-trip) · [XC-2](#xc-2-name-gate) · [XC-3](#xc-3-profile-completeness) · [XC-4](#xc-4-denial-shape) · [XC-5](#xc-5-errors-and-feedback) · [XC-6](#xc-6-rate-limiting) · [XC-7](#xc-7-deactivated-account) · [XC-8](#xc-8-applicant-facing-status-grouping) · [XC-9](#xc-9-applicant-email) · [XC-10](#xc-10-activity-panel)
 
 **[Anonymous (AN)](#anonymous-an)** — [AN-1](#an-1-browse-positions) · [AN-2](#an-2-view-a-position) · [AN-3](#an-3-start-applying-from-a-position) · [AN-4](#an-4-sign-in-with-an-email-code) · [AN-5](#an-5-request-a-new-code) · [AN-6](#an-6-set-your-name-on-first-sign-in) · [AN-7](#an-7-read-the-legal-pages) · [AN-8](#an-8-dev-bypass-sign-in)
 
@@ -92,6 +92,17 @@ Three applicant-facing email _events_, over two rendered templates, all through
 - **A failed send never fails the mutation.** The status write (or the submission) has already committed by the time the email is attempted; the send is a side effect dispatched in `after()`, and a provider failure is logged to `EmailLog` as `failed` and surfaced nowhere — not to the reviewer, not to the applicant.
 - **No opt-out, no preferences, no per-position copy.**
 
+### XC-10 Activity panel
+
+A `Sheet` reachable from every authenticated page, not just the dashboard — top-right of the sidebar's `h-14` header bar on desktop, and immediately left of the hamburger menu on mobile, so the control lands in the same visual position at both breakpoints. Hidden entirely for anonymous visitors. Opens from the right (`side="right"`), so it never reads as the same surface as `MobileNav`'s `side="left"` menu drawer.
+
+- **Composition** — everyone always gets **their own** non-draft applications on published positions, with public status only ([XC-8](#xc-8-applicant-facing-status-grouping)) — this covers a manager or admin who has also applied. Managers and admins additionally get a reviewer group: managed positions only for a manager, every published position for an admin, scoped the same way as [PM-8](#pm-8-work-the-application-queue)'s queue (`buildApplicationScopeWhere`). Both groups render when both apply.
+- **Self-filter** — a row in the reviewer group for the viewer's own application is dropped; it already appears in "Your applications", and without the filter a manager or admin who applied to a position they review would see their own application twice.
+- **Newest 10 per group** — each group is independently capped at 10, newest `submittedAt` first. The filter runs after the cap, so the reviewer group can show fewer than 10 when some of the newest rows are the viewer's own.
+- **Group headings** — only for a viewer with a reviewer group at all. "Your applications" first, then "Positions you manage" (manager) or "All positions" (admin); a group with no items is omitted. A plain applicant (no reviewer group) sees one flat list with no heading at all.
+- **Empty** — only when every visible group is empty: "No recent activity" plus a scope-specific description ("Updates to your applications will show up here." / "…and new applications to the positions you manage will show up here." / "…and new applications across all positions will show up here.").
+- **Freshness** — the panel lives in the shared layout, so Next keeps it across client-side navigations. It refreshes on a hard load, `router.refresh()`, or any server action whose `revalidatePath`/`revalidateTag` covers the layout — not on a plain link navigation. There is no unread state, badge, or mark-as-read, so this cannot tell a manager that something changed without them opening it and reading it.
+
 ---
 
 ## Anonymous (AN)
@@ -195,7 +206,7 @@ Any signed-in user. Every user is an applicant; manager and admin capabilities a
 ### AP-1 See your dashboard
 
 - **Trigger** — signing in, the logo, or the Home nav item (`/`).
-- **Happy path** — `UserDashboard` renders "Welcome back, <first name>" and streams five independently-suspended sections: the profile-completeness banner, an application summary, the three most recent applications, the three open positions closing soonest, and an activity feed. Each has its own skeleton. The applications widget's row is `title · trailing slot · status badge`; for a draft or withdrawn application the trailing slot carries the deadline instead of the usual submitted date — plain muted text normally, bold red `text-destructive-text` with the warning icon for any future deadline (`distant`, `soon`, or `urgent`) once the row is editable ([AP-10](#ap-10-track-your-applications)) — with the bare date, or the compact countdown (`Nh left`) once inside 24 hours, no `Closes`/`Closed` prefix. A `past` deadline always renders the plain muted date, regardless of status. And its subtitle appends `N closing soon` when any at-risk draft or withdrawn application exists, so one that would otherwise sit outside the top-3 by recency still surfaces here.
+- **Happy path** — `UserDashboard` renders "Welcome back, <first name>" and streams four independently-suspended sections: the profile-completeness banner, an application summary, the three most recent applications, and the three open positions closing soonest. Each has its own skeleton. The applications widget's row is `title · trailing slot · status badge`; for a draft or withdrawn application the trailing slot carries the deadline instead of the usual submitted date — plain muted text normally, bold red `text-destructive-text` with the warning icon for any future deadline (`distant`, `soon`, or `urgent`) once the row is editable ([AP-10](#ap-10-track-your-applications)) — with the bare date, or the compact countdown (`Nh left`) once inside 24 hours, no `Closes`/`Closed` prefix. A `past` deadline always renders the plain muted date, regardless of status. And its subtitle appends `N closing soon` when any at-risk draft or withdrawn application exists, so one that would otherwise sit outside the top-3 by recency still surfaces here. Recent activity lives in the activity panel, reachable from every page ([XC-10](#xc-10-activity-panel)), not on the dashboard.
 - **Failure / edge**
   - Anonymous → `redirect('/positions')` — routing, not denial.
   - No name → [XC-2](#xc-2-name-gate).
@@ -398,7 +409,7 @@ A user who manages at least one non-deleted position. Manager status is **derive
 ### PM-1 See your dashboard
 
 - **Trigger** — Home (`/`).
-- **Happy path** — `ManagerDashboard` — "Overview of applications for the positions you manage." — streams a pipeline summary, the three most recent applications, three managed positions, an activity feed, and the manager's own applications widget. Every section is scoped to positions they manage.
+- **Happy path** — `ManagerDashboard` — "Overview of applications for the positions you manage." — streams a pipeline summary, the three most recent applications, three managed positions, and the manager's own applications widget. Every section is scoped to positions they manage. Recent activity — a manager's own application activity as well as new applications to their managed positions — lives in the activity panel instead ([XC-10](#xc-10-activity-panel)).
 - **Failure / edge** — as [AP-1](#ap-1-see-your-dashboard); an admin gets `AdminDashboard` instead.
 - **End state** — read-only.
 
@@ -579,7 +590,7 @@ A user who manages at least one non-deleted position. Manager status is **derive
 
 ## Admin (AD)
 
-An admin is a **manager on every position**: every [Position manager](#position-manager-pm) workflow applies unchanged, with the scope widened from "positions I manage" to all of them (`buildReviewablePositionWhere`), and draft positions visible everywhere. Admins are exempt from the archived-position edit block ([PM-4](#pm-4-edit-position-details)) and from the self-removal rule ([PM-7](#pm-7-remove-a-manager)). Admins alone may set a position to `open`, from `draft` or `closed` ([PM-4](#pm-4-edit-position-details)) — publishing is a permission, not a workflow: no queue, no approve/reject, no notification back to the manager. This section covers only the admin-exclusive surfaces. The sidebar gains a **Settings** group with **Users**, **Global Questions** and **Email Log**, alongside the **Manage** group with **Manage Positions** and Applications a manager already sees ([PM intro](#position-manager-pm)).
+An admin is a **manager on every position**: every [Position manager](#position-manager-pm) workflow applies unchanged, with the scope widened from "positions I manage" to all of them (`buildReviewablePositionWhere`), and draft positions visible everywhere. Admins are exempt from the archived-position edit block ([PM-4](#pm-4-edit-position-details)) and from the self-removal rule ([PM-7](#pm-7-remove-a-manager)). Admins alone may set a position to `open`, from `draft` or `closed` ([PM-4](#pm-4-edit-position-details)) — publishing is a permission, not a workflow: no queue, no approve/reject, no notification back to the manager. This section covers only the admin-exclusive surfaces. The sidebar gains a **Settings** group with **Users**, **Global Questions** and **Email Log**, alongside the **Manage** group with **Manage Positions** and Applications a manager already sees ([PM intro](#position-manager-pm)). The activity panel's `all` scope follows the same widening — an admin's reviewer group covers every published position, alongside their own application activity ([XC-10](#xc-10-activity-panel)).
 
 ### AD-1 See every position
 
diff --git a/lib/constants.ts b/lib/constants.ts
index ff256e35..fa340882 100644
--- a/lib/constants.ts
+++ b/lib/constants.ts
@@ -3,7 +3,11 @@ import { z } from 'zod/v4';
 import { $Enums } from '@/prisma/client';
 import type { PositionStatus, Prisma, QuestionType } from '@/prisma/client';
 
-import type { PositionAvailability, UserRoleFilter } from '@/lib/types';
+import type {
+  ActivityScope,
+  PositionAvailability,
+  UserRoleFilter,
+} from '@/lib/types';
 
 import type { BadgeVariant } from '@/components/ui/badge';
 
@@ -1110,6 +1114,41 @@ export const STATUS_BADGE_VARIANT_TO_DOT: Record<BadgeVariant, string> = {
   outline: 'bg-border',
 };
 
+// Heading for the activity panel's applicant-scoped group — the only group
+// a 'none'-scope user sees, rendered with no heading at all in that case.
+export const ACTIVITY_MINE_TITLE = 'Your applications';
+
+// Drives the activity panel's Sheet description and its empty state, keyed
+// by the caller's derived scope (lib/types.ts#ActivityScope).
+export const ACTIVITY_FEED_COPY: Record<
+  ActivityScope,
+  {
+    description: string;
+    emptyDescription: string;
+    reviewedTitle: string | null;
+  }
+> = {
+  none: {
+    description: 'Updates to your applications.',
+    emptyDescription: 'Updates to your applications will show up here.',
+    reviewedTitle: null,
+  },
+  managed: {
+    description:
+      'Updates to your applications and new applications to the positions you manage.',
+    emptyDescription:
+      'Updates to your applications and new applications to the positions you manage will show up here.',
+    reviewedTitle: 'Positions you manage',
+  },
+  all: {
+    description:
+      'Updates to your applications and new applications across all positions.',
+    emptyDescription:
+      'Updates to your applications and new applications across all positions will show up here.',
+    reviewedTitle: 'All positions',
+  },
+};
+
 // Order is meaningful — rendered left to right on position cards.
 export const POSITION_CARD_STAT_STATUSES = [
   'applied',
diff --git a/lib/types.ts b/lib/types.ts
index 59a46eda..94c2addc 100644
--- a/lib/types.ts
+++ b/lib/types.ts
@@ -420,6 +420,17 @@ export type ActivityItem = {
   timestamp: Date;
 };
 
+// 'none' (plain applicant), 'managed' (manages ≥1 position), 'all' (admin).
+export type ActivityScope = 'none' | 'managed' | 'all';
+
+// mine is always the caller's own submitted applications; reviewed is the
+// self-filtered reviewer feed, empty when scope is 'none'.
+export type ActivityGroups = {
+  scope: ActivityScope;
+  mine: ActivityItem[];
+  reviewed: ActivityItem[];
+};
+
 // Exposes other users' identities — admin-gated contexts only, never a non-admin client.
 export type AdminUserListItem = Prisma.UserGetPayload<{
   select: {
diff --git a/prisma/data/activity.ts b/prisma/data/activity.ts
new file mode 100644
index 00000000..36c83b88
--- /dev/null
+++ b/prisma/data/activity.ts
@@ -0,0 +1,64 @@
+import 'server-only';
+
+import { cache } from 'react';
+
+import {
+  getMyRecentActivity,
+  getRecentApplications,
+} from '@/prisma/data/applications';
+import { isManager } from '@/prisma/data/managers';
+
+import {
+  APPLICATION_STATUS_BADGE_VARIANT,
+  APPLICATION_STATUS_LABELS,
+} from '@/lib/constants';
+import { type ActivityGroups, type ActivityItem } from '@/lib/types';
+import { getDisplayName, getRenamedTo } from '@/lib/utils';
+
+const ACTIVITY_TAKE = 10;
+
+// Deduped across the sidebar's and mobile nav's header instances by cache().
+export const getActivityGroups = cache(async function getActivityGroups(
+  userId: string,
+  isAdmin: boolean,
+): Promise<ActivityGroups> {
+  const scope = isAdmin
+    ? 'all'
+    : (await isManager(userId))
+      ? 'managed'
+      : 'none';
+
+  const [applications, reviewed] = await Promise.all([
+    getMyRecentActivity(userId, ACTIVITY_TAKE),
+    scope !== 'none'
+      ? getRecentApplications({ id: userId, isAdmin }, ACTIVITY_TAKE)
+      : Promise.resolve([]),
+  ]);
+
+  const mine: ActivityItem[] = applications.map((app) => {
+    const statusLabel = APPLICATION_STATUS_LABELS[app.status];
+    const variant = APPLICATION_STATUS_BADGE_VARIANT[app.status];
+    return {
+      id: app.id,
+      statusVariant: variant,
+      sentence: `Your application for ${app.position.title} is ${statusLabel}`,
+      timestamp: app.submittedAt,
+    };
+  });
+
+  const reviewedItems: ActivityItem[] = reviewed
+    .filter((app) => app.user.id !== userId)
+    .map((app) => {
+      const applicantLabel = getDisplayName(app);
+      const renamedTo = getRenamedTo(app);
+      const variant = APPLICATION_STATUS_BADGE_VARIANT[app.status];
+      return {
+        id: app.id,
+        statusVariant: variant,
+        sentence: `${applicantLabel}${renamedTo ? ` (${renamedTo})` : ''} applied for ${app.position.title}`,
+        timestamp: app.submittedAt,
+      };
+    });
+
+  return { scope, mine, reviewed: reviewedItems };
+});
diff --git a/tests/db/authorization.test.ts b/tests/db/authorization.test.ts
index 23bfca17..b14ab948 100644
--- a/tests/db/authorization.test.ts
+++ b/tests/db/authorization.test.ts
@@ -32,6 +32,7 @@ import {
   toggleUserAdmin,
 } from '@/prisma/actions/users';
 import type { Application, Position, User } from '@/prisma/client';
+import { getActivityGroups } from '@/prisma/data/activity';
 import {
   getApplicationForApply,
   getApplicationForReview,
@@ -833,3 +834,102 @@ describe('createPositionQuestion / updatePositionQuestion / deletePositionQuesti
     ).rejects.toThrow();
   });
 });
+
+describe('getActivityGroups composition and scoping', () => {
+  it('applicant only: scope none, mine is only their own application, no reviewed', async () => {
+    const groups = await getActivityGroups(applicantAppliedA.id, false);
+    expect(groups.scope).toBe('none');
+    expect(groups.mine.map((i) => i.id)).toEqual([applicationA1.id]);
+    expect(groups.reviewed).toEqual([]);
+  });
+
+  it('neither applicant nor manager: scope none, both groups empty', async () => {
+    const fresh = await createTestUser();
+    const groups = await getActivityGroups(fresh.id, false);
+    expect(groups.scope).toBe('none');
+    expect(groups.mine).toEqual([]);
+    expect(groups.reviewed).toEqual([]);
+  });
+
+  it('draft only: mine excludes the draft', async () => {
+    const groups = await getActivityGroups(applicantDraftA.id, false);
+    expect(groups.mine).toEqual([]);
+  });
+
+  it('manager only: scope managed, mine empty, reviewed contains the managed position’s application and excludes another manager’s', async () => {
+    const manager = await createTestUser();
+    const position = await createTestPosition(admin, { managers: [manager] });
+    const otherApplicant = await createTestUser();
+    const x = await createTestApplication(otherApplicant, position, {
+      status: 'applied',
+    });
+
+    const groups = await getActivityGroups(manager.id, false);
+    expect(groups.scope).toBe('managed');
+    expect(groups.mine).toEqual([]);
+    const reviewedIds = groups.reviewed.map((i) => i.id);
+    expect(reviewedIds).toContain(x.id);
+    expect(reviewedIds).not.toContain(applicationB1.id);
+  });
+
+  it('manager who is also an applicant: mine has public status and self-filter drops mine from reviewed', async () => {
+    const manager = await createTestUser();
+    const position = await createTestPosition(admin, { managers: [manager] });
+    const otherApplicant = await createTestUser();
+    const x = await createTestApplication(otherApplicant, position, {
+      status: 'applied',
+    });
+    const mB = await createTestApplication(manager, positionB, {
+      status: 'applied',
+    });
+    const mP = await createTestApplication(manager, position, {
+      status: 'reviewing',
+    });
+
+    const groups = await getActivityGroups(manager.id, false);
+    expect(groups.scope).toBe('managed');
+    const mineIds = groups.mine.map((i) => i.id);
+    expect(mineIds).toContain(mB.id);
+    expect(mineIds).toContain(mP.id);
+    const reviewingItem = groups.mine.find((i) => i.id === mP.id);
+    expect(reviewingItem?.sentence).toContain('is Applied');
+
+    const reviewedIds = groups.reviewed.map((i) => i.id);
+    expect(reviewedIds).toContain(x.id);
+    expect(reviewedIds).not.toContain(mP.id);
+    expect(reviewedIds).not.toContain(mB.id);
+    expect(reviewedIds).not.toContain(applicationB1.id);
+  });
+
+  it('admin who is also an applicant: scope all, mine contains own application, reviewed excludes self/drafts/deleted', async () => {
+    const positionQ = await createTestPosition(admin, { managers: [managerA] });
+    const otherApplicant = await createTestUser();
+    const y = await createTestApplication(otherApplicant, positionQ, {
+      status: 'applied',
+    });
+    const adminApp = await createTestApplication(admin, positionQ, {
+      status: 'applied',
+    });
+    const draftPositionApplicant = await createTestUser();
+    const onDraftPosition = await createTestApplication(
+      draftPositionApplicant,
+      draftPosition,
+      { status: 'applied' },
+    );
+    const deletedPositionApplicant = await createTestUser();
+    const onDeletedPosition = await createTestApplication(
+      deletedPositionApplicant,
+      deletedPosition,
+      { status: 'applied' },
+    );
+
+    const groups = await getActivityGroups(admin.id, true);
+    expect(groups.scope).toBe('all');
+    expect(groups.mine.map((i) => i.id)).toContain(adminApp.id);
+    const reviewedIds = groups.reviewed.map((i) => i.id);
+    expect(reviewedIds).toContain(y.id);
+    expect(reviewedIds).not.toContain(adminApp.id);
+    expect(reviewedIds).not.toContain(onDraftPosition.id);
+    expect(reviewedIds).not.toContain(onDeletedPosition.id);
+  });
+});

From 5eabc658f1eb706c69999843245cc26d6a052f9a Mon Sep 17 00:00:00 2001
From: Ciel Bellerose <kcbellerose@icloud.com>
Date: Thu, 24 Sep 2026 11:29:22 -0400
Subject: [PATCH 19/35] #617 address review feedback

Match the activity skeleton to the resolved two-heading layout for
reviewer scopes, and fall back to a muted message instead of the
global error boundary when the feed's fetch throws.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 components/features/activity-feed.tsx | 43 ++++++++++++++++++++++++---
 components/layouts/app-shell.tsx      |  2 +-
 2 files changed, 40 insertions(+), 5 deletions(-)

diff --git a/components/features/activity-feed.tsx b/components/features/activity-feed.tsx
index 25c62949..5db11af5 100644
--- a/components/features/activity-feed.tsx
+++ b/components/features/activity-feed.tsx
@@ -6,7 +6,7 @@ import {
   STATUS_BADGE_VARIANT_TO_DOT,
 } from '@/lib/constants';
 import { CONCEPT_ICONS } from '@/lib/icons';
-import { type ActivityItem } from '@/lib/types';
+import { type ActivityItem, type ActivityScope } from '@/lib/types';
 
 import { LocalTime } from '@/components/ui/local-time';
 import { SectionCardEmpty } from '@/components/ui/section-card';
@@ -70,7 +70,20 @@ interface ActivityFeedProps {
 }
 
 export async function ActivityFeed({ userId, isAdmin }: ActivityFeedProps) {
-  const { scope, mine, reviewed } = await getActivityGroups(userId, isAdmin);
+  let groups;
+  try {
+    groups = await getActivityGroups(userId, isAdmin);
+  } catch (error) {
+    console.error('getActivityGroups failed', error);
+    return (
+      <SectionCardEmpty
+        variant="compact"
+        message="Couldn't load recent activity."
+      />
+    );
+  }
+
+  const { scope, mine, reviewed } = groups;
   const copy = ACTIVITY_FEED_COPY[scope];
 
   if (mine.length === 0 && reviewed.length === 0)
@@ -104,10 +117,10 @@ export async function ActivityFeed({ userId, isAdmin }: ActivityFeedProps) {
   );
 }
 
-export function ActivityFeedListSkeleton() {
+function ActivityFeedRowsSkeleton({ count }: { count: number }) {
   return (
     <ol>
-      {Array.from({ length: 10 }).map((_, i) => (
+      {Array.from({ length: count }).map((_, i) => (
         <li
           key={i}
           className="flex items-center gap-3 border-b px-4 py-3 last:border-0"
@@ -120,3 +133,25 @@ export function ActivityFeedListSkeleton() {
     </ol>
   );
 }
+
+function ActivityFeedGroupSkeleton() {
+  return (
+    <div>
+      <div className="px-4 pt-4 pb-1">
+        <Skeleton className="h-3 w-28" />
+      </div>
+      <ActivityFeedRowsSkeleton count={5} />
+    </div>
+  );
+}
+
+export function ActivityFeedListSkeleton({ scope }: { scope: ActivityScope }) {
+  if (scope === 'none') return <ActivityFeedRowsSkeleton count={10} />;
+
+  return (
+    <>
+      <ActivityFeedGroupSkeleton />
+      <ActivityFeedGroupSkeleton />
+    </>
+  );
+}
diff --git a/components/layouts/app-shell.tsx b/components/layouts/app-shell.tsx
index 75378c87..0d5edf7a 100644
--- a/components/layouts/app-shell.tsx
+++ b/components/layouts/app-shell.tsx
@@ -48,7 +48,7 @@ export async function AppShell({ children }: { children: ReactNode }) {
 
     activityPanel = (
       <ActivityPanel description={ACTIVITY_FEED_COPY[scope].description}>
-        <Suspense fallback={<ActivityFeedListSkeleton />}>
+        <Suspense fallback={<ActivityFeedListSkeleton scope={scope} />}>
           <ActivityFeed userId={user.id} isAdmin={user.isAdmin} />
         </Suspense>
       </ActivityPanel>

From a5ff4e0a7c34f141861d55e8da5953bfec56dd09 Mon Sep 17 00:00:00 2001
From: Ciel Bellerose <kcbellerose@icloud.com>
Date: Thu, 24 Sep 2026 12:16:47 -0400
Subject: [PATCH 20/35] #617 address review feedback

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 components/features/activity-feed.tsx  | 12 +++++++-----
 components/features/activity-panel.tsx | 11 ++++++-----
 components/layouts/app-shell.tsx       |  3 +--
 lib/constants.ts                       | 15 +++------------
 4 files changed, 17 insertions(+), 24 deletions(-)

diff --git a/components/features/activity-feed.tsx b/components/features/activity-feed.tsx
index 5db11af5..8bd6a127 100644
--- a/components/features/activity-feed.tsx
+++ b/components/features/activity-feed.tsx
@@ -88,11 +88,13 @@ export async function ActivityFeed({ userId, isAdmin }: ActivityFeedProps) {
 
   if (mine.length === 0 && reviewed.length === 0)
     return (
-      <SectionCardEmpty
-        icon={CONCEPT_ICONS.activity}
-        title="No recent activity"
-        description={copy.emptyDescription}
-      />
+      <div className="px-4">
+        <SectionCardEmpty
+          icon={CONCEPT_ICONS.activity}
+          title="No recent activity"
+          description={copy.emptyDescription}
+        />
+      </div>
     );
 
   if (scope === 'none') return <ActivityFeedList items={mine} />;
diff --git a/components/features/activity-panel.tsx b/components/features/activity-panel.tsx
index b3b94612..beaaf1fd 100644
--- a/components/features/activity-panel.tsx
+++ b/components/features/activity-panel.tsx
@@ -8,17 +8,15 @@ import { Button } from '@/components/ui/button';
 import {
   Sheet,
   SheetContent,
-  SheetDescription,
   SheetTitle,
   SheetTrigger,
 } from '@/components/ui/sheet';
 
 interface ActivityPanelProps {
-  description: string;
   children: ReactNode;
 }
 
-export function ActivityPanel({ description, children }: ActivityPanelProps) {
+export function ActivityPanel({ children }: ActivityPanelProps) {
   const [open, setOpen] = useState(false);
   const ActivityIcon = CONCEPT_ICONS.activity;
 
@@ -29,10 +27,13 @@ export function ActivityPanel({ description, children }: ActivityPanelProps) {
           <ActivityIcon className="size-5" />
         </Button>
       </SheetTrigger>
-      <SheetContent side="right" className="flex flex-col gap-0 p-0">
+      <SheetContent
+        side="right"
+        className="flex flex-col gap-0 p-0"
+        aria-describedby={undefined}
+      >
         <div className="border-b px-4 py-3 pr-12">
           <SheetTitle className="text-base">Recent activity</SheetTitle>
-          <SheetDescription>{description}</SheetDescription>
         </div>
         <div className="min-h-0 flex-1 overflow-y-auto">{children}</div>
       </SheetContent>
diff --git a/components/layouts/app-shell.tsx b/components/layouts/app-shell.tsx
index 0d5edf7a..f7b67486 100644
--- a/components/layouts/app-shell.tsx
+++ b/components/layouts/app-shell.tsx
@@ -3,7 +3,6 @@ import { type ReactNode, Suspense } from 'react';
 import { isManager } from '@/prisma/data/managers';
 
 import { getIsBypass, getOptionalUser } from '@/lib/auth/server';
-import { ACTIVITY_FEED_COPY } from '@/lib/constants';
 import type { ActivityScope, NavIdentity } from '@/lib/types';
 
 import {
@@ -47,7 +46,7 @@ export async function AppShell({ children }: { children: ReactNode }) {
         : 'none';
 
     activityPanel = (
-      <ActivityPanel description={ACTIVITY_FEED_COPY[scope].description}>
+      <ActivityPanel>
         <Suspense fallback={<ActivityFeedListSkeleton scope={scope} />}>
           <ActivityFeed userId={user.id} isAdmin={user.isAdmin} />
         </Suspense>
diff --git a/lib/constants.ts b/lib/constants.ts
index fa340882..3d4158a3 100644
--- a/lib/constants.ts
+++ b/lib/constants.ts
@@ -1118,31 +1118,22 @@ export const STATUS_BADGE_VARIANT_TO_DOT: Record<BadgeVariant, string> = {
 // a 'none'-scope user sees, rendered with no heading at all in that case.
 export const ACTIVITY_MINE_TITLE = 'Your applications';
 
-// Drives the activity panel's Sheet description and its empty state, keyed
-// by the caller's derived scope (lib/types.ts#ActivityScope).
+// Drives the activity panel's empty state, keyed by the caller's derived
+// scope (lib/types.ts#ActivityScope).
 export const ACTIVITY_FEED_COPY: Record<
   ActivityScope,
-  {
-    description: string;
-    emptyDescription: string;
-    reviewedTitle: string | null;
-  }
+  { emptyDescription: string; reviewedTitle: string | null }
 > = {
   none: {
-    description: 'Updates to your applications.',
     emptyDescription: 'Updates to your applications will show up here.',
     reviewedTitle: null,
   },
   managed: {
-    description:
-      'Updates to your applications and new applications to the positions you manage.',
     emptyDescription:
       'Updates to your applications and new applications to the positions you manage will show up here.',
     reviewedTitle: 'Positions you manage',
   },
   all: {
-    description:
-      'Updates to your applications and new applications across all positions.',
     emptyDescription:
       'Updates to your applications and new applications across all positions will show up here.',
     reviewedTitle: 'All positions',

From 65785362ef05aa85ee971bb5944b554cfa3ce2de Mon Sep 17 00:00:00 2001
From: Ciel Bellerose <kcbellerose@icloud.com>
Date: Thu, 24 Sep 2026 15:23:16 -0400
Subject: [PATCH 21/35] #617 address review feedback

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 components/features/activity-feed.tsx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/components/features/activity-feed.tsx b/components/features/activity-feed.tsx
index 8bd6a127..66ba006a 100644
--- a/components/features/activity-feed.tsx
+++ b/components/features/activity-feed.tsx
@@ -27,7 +27,7 @@ export function ActivityFeedList({ items }: { items: ActivityItem[] }) {
               className={`mt-1.5 size-2 shrink-0 rounded-full ${dotClass}`}
               aria-hidden="true"
             />
-            <p className="line-clamp-2 min-w-0 flex-1 text-sm">
+            <p className="line-clamp-3 min-w-0 flex-1 text-sm">
               {item.sentence}
             </p>
             <LocalTime

From b9ea869882d5f1df1aa012bb72df6349fa477182 Mon Sep 17 00:00:00 2001
From: Ciel Bellerose <kcbellerose@icloud.com>
Date: Thu, 24 Sep 2026 18:16:38 -0400
Subject: [PATCH 22/35] #775 add PositionStatusEvent model and migration

Records every position status change, mirroring ApplicationStatusEvent,
so the activity panel can later show "position opened" items.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 .../migration.sql                             | 23 +++++++++++++++++++
 prisma/schema.prisma                          | 19 ++++++++++++++-
 2 files changed, 41 insertions(+), 1 deletion(-)
 create mode 100644 prisma/migrations/20260924221554_add_position_status_event/migration.sql

diff --git a/prisma/migrations/20260924221554_add_position_status_event/migration.sql b/prisma/migrations/20260924221554_add_position_status_event/migration.sql
new file mode 100644
index 00000000..d7ce7a5c
--- /dev/null
+++ b/prisma/migrations/20260924221554_add_position_status_event/migration.sql
@@ -0,0 +1,23 @@
+-- CreateTable
+CREATE TABLE "PositionStatusEvent" (
+    "id" TEXT NOT NULL,
+    "positionId" TEXT NOT NULL,
+    "from" "PositionStatus" NOT NULL,
+    "to" "PositionStatus" NOT NULL,
+    "changedById" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "PositionStatusEvent_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE INDEX "PositionStatusEvent_positionId_createdAt_idx" ON "PositionStatusEvent"("positionId", "createdAt");
+
+-- CreateIndex
+CREATE INDEX "PositionStatusEvent_to_createdAt_idx" ON "PositionStatusEvent"("to", "createdAt");
+
+-- AddForeignKey
+ALTER TABLE "PositionStatusEvent" ADD CONSTRAINT "PositionStatusEvent_positionId_fkey" FOREIGN KEY ("positionId") REFERENCES "Position"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "PositionStatusEvent" ADD CONSTRAINT "PositionStatusEvent_changedById_fkey" FOREIGN KEY ("changedById") REFERENCES "User"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
diff --git a/prisma/schema.prisma b/prisma/schema.prisma
index d8f89a88..3a35b5ca 100644
--- a/prisma/schema.prisma
+++ b/prisma/schema.prisma
@@ -111,6 +111,7 @@ model User {
   updatedPositionAppAnswers PositionApplicationAnswer[] @relation("PositionApplicationAnswerUpdatedBy")
   deletedPositionAppAnswers PositionApplicationAnswer[] @relation("PositionApplicationAnswerDeletedBy")
   applicationStatusEvents   ApplicationStatusEvent[]    @relation("ApplicationStatusEventChangedBy")
+  positionStatusEvents      PositionStatusEvent[]       @relation("PositionStatusEventChangedBy")
 }
 
 model Position {
@@ -131,9 +132,10 @@ model Position {
   updatedBy User  @relation("PositionUpdatedBy", fields: [updatedById], references: [id])
   deletedBy User? @relation("PositionDeletedBy", fields: [deletedById], references: [id])
 
-  managers     User[]             @relation("PositionManagers")
+  managers     User[]                @relation("PositionManagers")
   questions    PositionQuestion[]
   applications Application[]
+  statusEvents PositionStatusEvent[]
 }
 
 model GlobalQuestion {
@@ -250,6 +252,21 @@ model ApplicationStatusEvent {
   @@index([applicationId, createdAt])
 }
 
+model PositionStatusEvent {
+  id          String         @id @default(uuid(7))
+  positionId  String
+  from        PositionStatus
+  to          PositionStatus
+  changedById String
+  createdAt   DateTime       @default(now())
+
+  position  Position @relation(fields: [positionId], references: [id])
+  changedBy User     @relation("PositionStatusEventChangedBy", fields: [changedById], references: [id])
+
+  @@index([positionId, createdAt])
+  @@index([to, createdAt])
+}
+
 model GlobalApplicationAnswer {
   id               String       @id @default(uuid(7))
   applicationId    String

From f1c207dab87019ea514f2ff70850244ee2980677 Mon Sep 17 00:00:00 2001
From: Ciel Bellerose <kcbellerose@icloud.com>
Date: Thu, 24 Sep 2026 18:21:41 -0400
Subject: [PATCH 23/35] #775 record and check position status events in
 updatePositionStatus

Wraps the status write in a transaction with a compare-and-swap on the
prior status, so a concurrent change surfaces a clear error instead of
silently overwriting, and writes a PositionStatusEvent per real move.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 lib/constants.ts                   | 13 ++++++++
 prisma/actions/position-actions.ts | 53 +++++++++++++++++++++---------
 2 files changed, 50 insertions(+), 16 deletions(-)

diff --git a/lib/constants.ts b/lib/constants.ts
index 3d4158a3..981293c1 100644
--- a/lib/constants.ts
+++ b/lib/constants.ts
@@ -824,6 +824,9 @@ export const POSITION_CLOSED_DRAFT_BLOCKED_ERROR =
   'A closed position cannot go back to draft. Reopen it instead, or leave it closed.';
 export const POSITION_UNPUBLISH_BLOCKED_ERROR =
   'Someone has already started an application, so this position cannot go back to draft. Close it instead.';
+// A concurrent save changed the position's status between load and submit.
+export const POSITION_STATUS_CHANGED_ERROR =
+  'This position just changed. Refresh to see its current status.';
 export const POSITION_REOPEN_PAST_CLOSE_ERROR =
   "This position's close date has passed. Clear or extend the close date to reopen it.";
 
@@ -1140,6 +1143,16 @@ export const ACTIVITY_FEED_COPY: Record<
   },
 };
 
+// Activity panel copy for a position's "to: open" event, keyed by the status
+// it moved from — reopened (from closed) reads differently than opened.
+export const POSITION_ACTIVITY_SENTENCE: Record<
+  'draft' | 'closed',
+  (title: string) => string
+> = {
+  draft: (title) => `${title} was opened`,
+  closed: (title) => `${title} was reopened`,
+};
+
 // Order is meaningful — rendered left to right on position cards.
 export const POSITION_CARD_STAT_STATUSES = [
   'applied',
diff --git a/prisma/actions/position-actions.ts b/prisma/actions/position-actions.ts
index 34526f0f..bbaad20c 100644
--- a/prisma/actions/position-actions.ts
+++ b/prisma/actions/position-actions.ts
@@ -22,6 +22,7 @@ import {
   POSITION_OPENS_AT_ORDER_ERROR,
   POSITION_OPENS_AT_PAST_ERROR,
   POSITION_OPEN_REQUIRES_ADMIN_ERROR,
+  POSITION_STATUS_CHANGED_ERROR,
   POSITION_STATUS_VALUES,
   POSITION_UNPUBLISH_BLOCKED_ERROR,
   createPositionFormSchema,
@@ -274,27 +275,47 @@ export async function updatePositionStatus(
   if (transitionError) return { error: transitionError };
 
   // Folded into the where (not a separate count) so a concurrent first
-  // application can't slip past the check above — same shape as deletePosition.
-  const updateResult = await prisma.position.updateMany({
-    where: {
-      id,
-      deletedAt: null,
-      ...(isUnpublishing
-        ? { applications: { none: { deletedAt: null } } }
-        : {}),
-    },
-    data: { status, updatedById: user.id },
+  // application, or a concurrent status change, can't slip past the checks
+  // above — same shape as deletePosition. status: existing.status is a
+  // compare-and-swap: it makes the event's `from` provably the replaced
+  // status, and stops a concurrent double-open from writing two events.
+  const updateCount = await prisma.$transaction(async (tx) => {
+    const updateResult = await tx.position.updateMany({
+      where: {
+        id,
+        deletedAt: null,
+        status: existing.status,
+        ...(isUnpublishing
+          ? { applications: { none: { deletedAt: null } } }
+          : {}),
+      },
+      data: { status, updatedById: user.id },
+    });
+
+    if (updateResult.count === 1 && existing.status !== status)
+      await tx.positionStatusEvent.create({
+        data: {
+          positionId: id,
+          from: existing.status,
+          to: status,
+          changedById: user.id,
+        },
+      });
+
+    return updateResult.count;
   });
 
-  if (updateResult.count === 0) {
-    const stillExists = await prisma.position.findFirst({
+  if (updateCount === 0) {
+    const current = await prisma.position.findFirst({
       where: { id, deletedAt: null },
-      select: { id: true },
+      select: { status: true },
     });
+    if (!current) return { error: 'This position no longer exists.' };
     return {
-      error: stillExists
-        ? POSITION_UNPUBLISH_BLOCKED_ERROR
-        : 'This position no longer exists.',
+      error:
+        current.status !== existing.status
+          ? POSITION_STATUS_CHANGED_ERROR
+          : POSITION_UNPUBLISH_BLOCKED_ERROR,
     };
   }
 

From 8f72e43d814e5a931f4eadbc7f8be8f0eed5a6e8 Mon Sep 17 00:00:00 2001
From: Ciel Bellerose <kcbellerose@icloud.com>
Date: Thu, 24 Sep 2026 18:21:48 -0400
Subject: [PATCH 24/35] #775 surface position openings in the activity panel's
 reviewer group

getRecentPositionOpenings reads PositionStatusEvent rows scoped like
the existing application feed; getActivityGroups merges them in by
time and caps the combined reviewer group at 10.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 lib/types.ts             | 14 ++++++++++++++
 prisma/data/activity.ts  | 28 ++++++++++++++++++++++++++--
 prisma/data/positions.ts | 23 +++++++++++++++++++++++
 3 files changed, 63 insertions(+), 2 deletions(-)

diff --git a/lib/types.ts b/lib/types.ts
index 94c2addc..0d88c458 100644
--- a/lib/types.ts
+++ b/lib/types.ts
@@ -413,11 +413,14 @@ export type QuestionFileDownload = {
 };
 
 // sentence is pre-rendered safe copy; statusVariant drives the dot color.
+// href is set only for rows that link somewhere (position openings); plain
+// application rows leave it undefined and render as static text.
 export type ActivityItem = {
   id: string;
   statusVariant: BadgeVariant;
   sentence: string;
   timestamp: Date;
+  href?: string;
 };
 
 // 'none' (plain applicant), 'managed' (manages ≥1 position), 'all' (admin).
@@ -431,6 +434,17 @@ export type ActivityGroups = {
   reviewed: ActivityItem[];
 };
 
+// Matches getRecentPositionOpenings's select in prisma/data/positions.ts.
+// No actor identity selected — changedBy never reaches the activity panel.
+export type PositionOpeningActivity = Prisma.PositionStatusEventGetPayload<{
+  select: {
+    id: true;
+    from: true;
+    createdAt: true;
+    position: { select: { id: true; title: true } };
+  };
+}>;
+
 // Exposes other users' identities — admin-gated contexts only, never a non-admin client.
 export type AdminUserListItem = Prisma.UserGetPayload<{
   select: {
diff --git a/prisma/data/activity.ts b/prisma/data/activity.ts
index 36c83b88..425540f7 100644
--- a/prisma/data/activity.ts
+++ b/prisma/data/activity.ts
@@ -7,10 +7,13 @@ import {
   getRecentApplications,
 } from '@/prisma/data/applications';
 import { isManager } from '@/prisma/data/managers';
+import { getRecentPositionOpenings } from '@/prisma/data/positions';
 
 import {
   APPLICATION_STATUS_BADGE_VARIANT,
   APPLICATION_STATUS_LABELS,
+  POSITION_ACTIVITY_SENTENCE,
+  POSITION_STATUS_BADGE_VARIANT,
 } from '@/lib/constants';
 import { type ActivityGroups, type ActivityItem } from '@/lib/types';
 import { getDisplayName, getRenamedTo } from '@/lib/utils';
@@ -28,11 +31,14 @@ export const getActivityGroups = cache(async function getActivityGroups(
       ? 'managed'
       : 'none';
 
-  const [applications, reviewed] = await Promise.all([
+  const [applications, reviewed, openings] = await Promise.all([
     getMyRecentActivity(userId, ACTIVITY_TAKE),
     scope !== 'none'
       ? getRecentApplications({ id: userId, isAdmin }, ACTIVITY_TAKE)
       : Promise.resolve([]),
+    scope !== 'none'
+      ? getRecentPositionOpenings({ id: userId, isAdmin }, ACTIVITY_TAKE)
+      : Promise.resolve([]),
   ]);
 
   const mine: ActivityItem[] = applications.map((app) => {
@@ -46,7 +52,7 @@ export const getActivityGroups = cache(async function getActivityGroups(
     };
   });
 
-  const reviewedItems: ActivityItem[] = reviewed
+  const applicationItems: ActivityItem[] = reviewed
     .filter((app) => app.user.id !== userId)
     .map((app) => {
       const applicantLabel = getDisplayName(app);
@@ -60,5 +66,23 @@ export const getActivityGroups = cache(async function getActivityGroups(
       };
     });
 
+  // to: 'open' means from can never be 'open' — narrow with a guard, not a cast.
+  const openingItems: ActivityItem[] = openings
+    .filter(
+      (event): event is typeof event & { from: 'draft' | 'closed' } =>
+        event.from !== 'open',
+    )
+    .map((event) => ({
+      id: event.id,
+      statusVariant: POSITION_STATUS_BADGE_VARIANT.open,
+      sentence: POSITION_ACTIVITY_SENTENCE[event.from](event.position.title),
+      timestamp: event.createdAt,
+      href: `/positions/${event.position.id}`,
+    }));
+
+  const reviewedItems = [...applicationItems, ...openingItems]
+    .sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime())
+    .slice(0, ACTIVITY_TAKE);
+
   return { scope, mine, reviewed: reviewedItems };
 });
diff --git a/prisma/data/positions.ts b/prisma/data/positions.ts
index 9b484a3f..e001dd57 100644
--- a/prisma/data/positions.ts
+++ b/prisma/data/positions.ts
@@ -2,6 +2,7 @@ import 'server-only';
 
 import { cache } from 'react';
 
+import { buildReviewablePositionWhere } from '@/lib/auth/scopes';
 import {
   MANAGED_POSITIONS_WINDOW_DAYS,
   NON_REVIEWABLE_APPLICATION_STATUSES,
@@ -17,7 +18,9 @@ import {
   type PositionDeletionSummary,
   type PositionDetail,
   type PositionForEdit,
+  type PositionOpeningActivity,
   type PositionWithQuestions,
+  type Reviewer,
 } from '@/lib/types';
 import {
   getPositionAvailability,
@@ -378,3 +381,23 @@ export async function getPositionDeletionSummary(
 
   return { submittedCount, draftCount };
 }
+
+// Feeds the activity panel's reviewer group — scoped identically to
+// getRecentApplications, so a position leaving the reviewer's scope (returned
+// to draft, or the reviewer no longer manages it) drops its opening out too.
+export async function getRecentPositionOpenings(
+  reviewer: Reviewer,
+  take: number,
+): Promise<PositionOpeningActivity[]> {
+  return prisma.positionStatusEvent.findMany({
+    where: { to: 'open', position: buildReviewablePositionWhere(reviewer) },
+    select: {
+      id: true,
+      from: true,
+      createdAt: true,
+      position: { select: { id: true, title: true } },
+    },
+    orderBy: [{ createdAt: 'desc' }, { id: 'desc' }],
+    take,
+  });
+}

From e827203de6e4a1e709a16427bf3e85625109090f Mon Sep 17 00:00:00 2001
From: Ciel Bellerose <kcbellerose@icloud.com>
Date: Thu, 24 Sep 2026 18:21:53 -0400
Subject: [PATCH 25/35] #775 link position-opening rows in the activity panel

A row with an href renders as a Link wrapped in SheetClose so opening
it also closes the panel; plain application rows are unaffected.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 components/features/activity-feed.tsx | 63 +++++++++++++++++----------
 1 file changed, 40 insertions(+), 23 deletions(-)

diff --git a/components/features/activity-feed.tsx b/components/features/activity-feed.tsx
index 66ba006a..f6578090 100644
--- a/components/features/activity-feed.tsx
+++ b/components/features/activity-feed.tsx
@@ -1,3 +1,5 @@
+import Link from 'next/link';
+
 import { getActivityGroups } from '@/prisma/data/activity';
 
 import {
@@ -10,34 +12,49 @@ import { type ActivityItem, type ActivityScope } from '@/lib/types';
 
 import { LocalTime } from '@/components/ui/local-time';
 import { SectionCardEmpty } from '@/components/ui/section-card';
+import { SheetClose } from '@/components/ui/sheet';
 import { Skeleton } from '@/components/ui/skeleton';
 
+function ActivityFeedRowContent({ item }: { item: ActivityItem }) {
+  const dotClass = STATUS_BADGE_VARIANT_TO_DOT[item.statusVariant];
+
+  return (
+    <>
+      <span
+        className={`mt-1.5 size-2 shrink-0 rounded-full ${dotClass}`}
+        aria-hidden="true"
+      />
+      <p className="line-clamp-3 min-w-0 flex-1 text-sm">{item.sentence}</p>
+      <LocalTime
+        date={item.timestamp}
+        precision="relative"
+        className="text-muted-foreground ml-auto shrink-0 text-xs tabular-nums"
+      />
+    </>
+  );
+}
+
 export function ActivityFeedList({ items }: { items: ActivityItem[] }) {
   return (
     <ol>
-      {items.map((item) => {
-        const dotClass = STATUS_BADGE_VARIANT_TO_DOT[item.statusVariant];
-
-        return (
-          <li
-            key={item.id}
-            className="flex items-start gap-3 border-b px-4 py-3 last:border-0"
-          >
-            <span
-              className={`mt-1.5 size-2 shrink-0 rounded-full ${dotClass}`}
-              aria-hidden="true"
-            />
-            <p className="line-clamp-3 min-w-0 flex-1 text-sm">
-              {item.sentence}
-            </p>
-            <LocalTime
-              date={item.timestamp}
-              precision="relative"
-              className="text-muted-foreground ml-auto shrink-0 text-xs tabular-nums"
-            />
-          </li>
-        );
-      })}
+      {items.map((item) => (
+        <li key={item.id} className="border-b last:border-0">
+          {item.href ? (
+            <SheetClose asChild>
+              <Link
+                href={item.href}
+                className="hover:bg-muted/50 focus-visible:ring-ring flex items-start gap-3 px-4 py-3 outline-none focus-visible:ring-2"
+              >
+                <ActivityFeedRowContent item={item} />
+              </Link>
+            </SheetClose>
+          ) : (
+            <div className="flex items-start gap-3 px-4 py-3">
+              <ActivityFeedRowContent item={item} />
+            </div>
+          )}
+        </li>
+      ))}
     </ol>
   );
 }

From 35d4664cc6113699bb2618841a94ef5a90181110 Mon Sep 17 00:00:00 2001
From: Ciel Bellerose <kcbellerose@icloud.com>
Date: Thu, 24 Sep 2026 18:21:59 -0400
Subject: [PATCH 26/35] #775 add test coverage for position-opening activity
 events

Covers scoping (manager, other manager, applicant, admin), reopen vs
close, returning to draft, and merge-and-cap behavior in
getActivityGroups, plus the event write itself in updatePositionStatus.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 tests/db/authorization.test.ts        | 137 +++++++++++++++++++++++++-
 tests/db/position-transitions.test.ts |  78 +++++++++++++++
 tests/helpers/fixtures.ts             |   4 +
 3 files changed, 218 insertions(+), 1 deletion(-)

diff --git a/tests/db/authorization.test.ts b/tests/db/authorization.test.ts
index b14ab948..f128adf1 100644
--- a/tests/db/authorization.test.ts
+++ b/tests/db/authorization.test.ts
@@ -20,7 +20,10 @@ import {
   deleteGlobalQuestion,
   updateGlobalQuestion,
 } from '@/prisma/actions/global-questions';
-import { searchUsers } from '@/prisma/actions/position-actions';
+import {
+  searchUsers,
+  updatePositionStatus,
+} from '@/prisma/actions/position-actions';
 import {
   createPositionQuestion,
   deletePositionQuestion,
@@ -932,4 +935,136 @@ describe('getActivityGroups composition and scoping', () => {
     expect(reviewedIds).not.toContain(onDraftPosition.id);
     expect(reviewedIds).not.toContain(onDeletedPosition.id);
   });
+
+  it('admin opens a draft: the listed manager sees a "was opened" item linking to the position', async () => {
+    const manager = await createTestUser();
+    const position = await createTestPosition(admin, {
+      managers: [manager],
+      status: 'draft',
+    });
+
+    actAs(admin);
+    const result = await updatePositionStatus({
+      id: position.id,
+      status: 'open',
+    });
+    expect(result).toBeUndefined();
+
+    const groups = await getActivityGroups(manager.id, false);
+    expect(groups.scope).toBe('managed');
+    const item = groups.reviewed.find((i) =>
+      i.sentence.includes(position.title),
+    );
+    expect(item).toBeDefined();
+    expect(item?.sentence).toBe(`${position.title} was opened`);
+    expect(item?.href).toBe(`/positions/${position.id}`);
+  });
+
+  it('a manager of a different position does not see the opening', async () => {
+    const manager = await createTestUser();
+    const otherManager = await createTestUser();
+    const position = await createTestPosition(admin, {
+      managers: [manager],
+      status: 'draft',
+    });
+
+    actAs(admin);
+    await updatePositionStatus({ id: position.id, status: 'open' });
+
+    const groups = await getActivityGroups(otherManager.id, false);
+    const ids = groups.reviewed.map((i) => i.sentence);
+    expect(ids).not.toContain(`${position.title} was opened`);
+  });
+
+  it('an applicant on the position (not a manager) never gets a reviewer group', async () => {
+    const manager = await createTestUser();
+    const position = await createTestPosition(admin, {
+      managers: [manager],
+      status: 'draft',
+    });
+
+    actAs(admin);
+    await updatePositionStatus({ id: position.id, status: 'open' });
+
+    const positionApplicant = await createTestUser();
+    await createTestApplication(positionApplicant, position, {
+      status: 'applied',
+    });
+
+    const groups = await getActivityGroups(positionApplicant.id, false);
+    expect(groups.scope).toBe('none');
+    expect(groups.reviewed).toEqual([]);
+  });
+
+  it('an admin sees the opening under "all" with no self-filter', async () => {
+    const manager = await createTestUser();
+    const position = await createTestPosition(admin, {
+      managers: [manager],
+      status: 'draft',
+    });
+
+    actAs(admin);
+    await updatePositionStatus({ id: position.id, status: 'open' });
+
+    const groups = await getActivityGroups(admin.id, true);
+    expect(groups.scope).toBe('all');
+    const sentences = groups.reviewed.map((i) => i.sentence);
+    expect(sentences).toContain(`${position.title} was opened`);
+  });
+
+  it('reopening (open -> closed -> open) shows "was reopened"; the close produces no item', async () => {
+    const manager = await createTestUser();
+    const position = await createTestPosition(admin, {
+      managers: [manager],
+      status: 'open',
+    });
+
+    actAs(admin);
+    await updatePositionStatus({ id: position.id, status: 'closed' });
+    await updatePositionStatus({ id: position.id, status: 'open' });
+
+    const groups = await getActivityGroups(manager.id, false);
+    const sentences = groups.reviewed.map((i) => i.sentence);
+    expect(sentences).toContain(`${position.title} was reopened`);
+    expect(sentences).not.toContain(`${position.title} was closed`);
+  });
+
+  it('returning to draft after opening drops the item for the manager', async () => {
+    const manager = await createTestUser();
+    const position = await createTestPosition(admin, {
+      managers: [manager],
+      status: 'draft',
+    });
+
+    actAs(admin);
+    await updatePositionStatus({ id: position.id, status: 'open' });
+    await updatePositionStatus({ id: position.id, status: 'draft' });
+
+    const groups = await getActivityGroups(manager.id, false);
+    const sentences = groups.reviewed.map((i) => i.sentence);
+    expect(sentences).not.toContain(`${position.title} was opened`);
+  });
+
+  it('merges openings with applications by time and caps the combined feed at 10', async () => {
+    const manager = await createTestUser();
+    const position = await createTestPosition(admin, {
+      managers: [manager],
+      status: 'draft',
+    });
+
+    actAs(admin);
+    await updatePositionStatus({ id: position.id, status: 'open' });
+
+    const newerApplicant = await createTestUser();
+    const newerApplication = await createTestApplication(
+      newerApplicant,
+      position,
+      { status: 'applied' },
+    );
+
+    const groups = await getActivityGroups(manager.id, false);
+    expect(groups.reviewed.length).toBeLessThanOrEqual(10);
+    const newestId = groups.reviewed[0]?.id;
+    expect(newestId).toBe(newerApplication.id);
+  });
 });
diff --git a/tests/db/position-transitions.test.ts b/tests/db/position-transitions.test.ts
index 68ab3daa..4feb1b78 100644
--- a/tests/db/position-transitions.test.ts
+++ b/tests/db/position-transitions.test.ts
@@ -51,6 +51,13 @@ async function status(id: string): Promise<string> {
   return row.status;
 }
 
+async function events(positionId: string) {
+  return prisma.positionStatusEvent.findMany({
+    where: { positionId },
+    orderBy: { createdAt: 'asc' },
+  });
+}
+
 beforeAll(async () => {
   admin = await createTestUser({ isAdmin: true });
   manager = await createTestUser();
@@ -197,5 +204,76 @@ describe('unchanged status', () => {
     });
     expect(result).toBeUndefined();
     expect(await status(position.id)).toBe('open');
+
+    expect(await events(position.id)).toEqual([]);
+  });
+});
+
+describe('PositionStatusEvent writes', () => {
+  it('writes exactly one event with the right from/to/changedById for each legal transition', async () => {
+    const position = await makePosition({ status: 'draft' });
+
+    actAs(admin);
+    await updatePositionStatus({ id: position.id, status: 'open' });
+    let rows = await events(position.id);
+    expect(rows).toHaveLength(1);
+    expect(rows[0]).toMatchObject({
+      from: 'draft',
+      to: 'open',
+      changedById: admin.id,
+    });
+
+    actAs(manager);
+    await updatePositionStatus({ id: position.id, status: 'closed' });
+    rows = await events(position.id);
+    expect(rows).toHaveLength(2);
+    expect(rows[1]).toMatchObject({
+      from: 'open',
+      to: 'closed',
+      changedById: manager.id,
+    });
+
+    actAs(admin);
+    await updatePositionStatus({ id: position.id, status: 'open' });
+    rows = await events(position.id);
+    expect(rows).toHaveLength(3);
+    expect(rows[2]).toMatchObject({
+      from: 'closed',
+      to: 'open',
+      changedById: admin.id,
+    });
+
+    actAs(manager);
+    await updatePositionStatus({ id: position.id, status: 'draft' });
+    rows = await events(position.id);
+    expect(rows).toHaveLength(4);
+    expect(rows[3]).toMatchObject({
+      from: 'open',
+      to: 'draft',
+      changedById: manager.id,
+    });
+  });
+
+  it('writes no event on a same-status save', async () => {
+    const position = await makePosition({ status: 'open' });
+    await createTestApplication(applicant, position, { status: 'applied' });
+
+    actAs(manager);
+    await updatePositionStatus({ id: position.id, status: 'open' });
+
+    expect(await events(position.id)).toEqual([]);
+  });
+
+  it('writes no event on a blocked transition', async () => {
+    const position = await makePosition({ status: 'draft' });
+
+    actAs(manager);
+    const result = await updatePositionStatus({
+      id: position.id,
+      status: 'closed',
+    });
+    expect(result).toEqual({ error: POSITION_DRAFT_CLOSE_BLOCKED_ERROR });
+
+    expect(await events(position.id)).toEqual([]);
   });
 });
diff --git a/tests/helpers/fixtures.ts b/tests/helpers/fixtures.ts
index 7ad6c482..d339effa 100644
--- a/tests/helpers/fixtures.ts
+++ b/tests/helpers/fixtures.ts
@@ -189,6 +189,10 @@ export async function cleanupFixtures(): Promise<void> {
     },
   });
 
+  await prisma.positionStatusEvent.deleteMany({
+    where: { OR: [{ changedBy: testUser }, { position: testPosition }] },
+  });
+
   await prisma.application.deleteMany({
     where: { OR: [{ user: testUser }, { position: testPosition }] },
   });

From 91dddcba67cf7bfdfef5ba7b79a2cd26599c417c Mon Sep 17 00:00:00 2001
From: Ciel Bellerose <kcbellerose@icloud.com>
Date: Thu, 24 Sep 2026 18:22:05 -0400
Subject: [PATCH 27/35] #775 document position-opening activity in WORKFLOWS
 and PERMISSIONS

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 docs/PERMISSIONS.md |  3 ++-
 docs/WORKFLOWS.md   | 11 ++++++-----
 2 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/docs/PERMISSIONS.md b/docs/PERMISSIONS.md
index c43a82ee..d632a1a8 100644
--- a/docs/PERMISSIONS.md
+++ b/docs/PERMISSIONS.md
@@ -100,7 +100,7 @@ Four principals, each derived rather than stored as a single role field:
 | `draft → closed`, `closed → draft` | no          | A draft has never accepted applications — nothing to close. A closed position never returns to draft — reopen it instead                                                                |
 | create as anything but `draft`     | no          | `createPosition` takes no status input — every position is born `draft`                                                                                                                 |
 
-- **Publishing is a permission, not a workflow.** There is no submit-for-approval step, no pending queue, no approve/reject with a reason, and no notification to the manager. A manager creates and shapes a draft; an admin performs the act of setting it `open`, from either `draft` or `closed`. Content edits after publishing stay unrestricted — approval gates the status change, not the position's fields.
+- **Publishing is a permission, not a workflow.** There is no submit-for-approval step, no pending queue, no approve/reject with a reason, and the only signal back to the manager is an activity-panel item (`docs/WORKFLOWS.md` XC-10). A manager creates and shapes a draft; an admin performs the act of setting it `open`, from either `draft` or `closed`. Content edits after publishing stay unrestricted — approval gates the status change, not the position's fields.
 - **Reopening past `closesAt` is a silent no-op**, not a reopen — `getPositionAvailability` (`lib/utils.ts`) still returns `closed_by_date`, so the position reads Open and accepts nothing. Reject it: `{ error: "This position's close date has passed. Clear or extend the close date to reopen it." }`
 - **Unpublishing hides a position out from under applicants who already have work in it**, so the first application — including a draft nobody has submitted — is one-way out of `open`: `{ error: 'Someone has already started an application, so this position cannot go back to draft. Close it instead.' }`
 - **A draft was never listed, so it has nothing to close.** `draft → closed` is rejected with `{ error: 'A draft has never accepted applications, so there is nothing to close. Publish it first, or leave it as a draft.' }` — a manager who wants a draft off the board leaves it as a draft, or publishes and closes it instead.
@@ -138,6 +138,7 @@ Confirmations carry the risk the freezes don't.
 
 - **Archived is derived, never stored.** `isPositionActive` (`lib/utils.ts`) is the single source of truth, fed by `positionActivitySelect` / `withPositionActivity` (`prisma/data/positions.ts`). A second implementation is an authorization bug, not a display bug.
 - A position is archived once it is closed (`status: 'closed'`, or `open` past `closesAt`) for more than `MANAGED_POSITIONS_WINDOW_DAYS` **and** no application status has changed in that same window. Unresolved applications no longer pin a position active indefinitely — only recent activity does.
+- **"Activity" here means an `ApplicationStatusEvent` only.** `PositionStatusEvent` (the activity-panel "was opened"/"was reopened" item, `docs/WORKFLOWS.md` XC-10) is not read by `positionActivitySelect`/`withPositionActivity` and does not reset the archive window — reopening a position starts the clock over via its own `status`/`closesAt`, not via this event table.
 - **There is no manual archive or unarchive.** A position leaves archive when an admin reopens it with a future close date, or — since a status change is itself activity — the moment a reviewer moves one of its applications, admin or not.
 - Managers are denied with `ARCHIVED_POSITION_EDIT_ERROR` (`lib/constants.ts`), returned by the four position-field actions (`updatePositionTitle`, `updatePositionDescription`, `updatePositionSchedule`, `updatePositionStatus`), the three position-question actions, and `addPositionManager`/`removePositionManager`. Admins short-circuit the check inside `checkPositionEditable` (`prisma/data/positions.ts`).
 - **The edit page does not 404.** It renders Details/Availability as read-only text, `PositionQuestionsReadonly`, and `PositionManagersReadonly` behind an explanatory callout, so a manager can still read what they can no longer change.
diff --git a/docs/WORKFLOWS.md b/docs/WORKFLOWS.md
index 80d3c91a..f85c7d4b 100644
--- a/docs/WORKFLOWS.md
+++ b/docs/WORKFLOWS.md
@@ -96,9 +96,9 @@ Three applicant-facing email _events_, over two rendered templates, all through
 
 A `Sheet` reachable from every authenticated page, not just the dashboard — top-right of the sidebar's `h-14` header bar on desktop, and immediately left of the hamburger menu on mobile, so the control lands in the same visual position at both breakpoints. Hidden entirely for anonymous visitors. Opens from the right (`side="right"`), so it never reads as the same surface as `MobileNav`'s `side="left"` menu drawer.
 
-- **Composition** — everyone always gets **their own** non-draft applications on published positions, with public status only ([XC-8](#xc-8-applicant-facing-status-grouping)) — this covers a manager or admin who has also applied. Managers and admins additionally get a reviewer group: managed positions only for a manager, every published position for an admin, scoped the same way as [PM-8](#pm-8-work-the-application-queue)'s queue (`buildApplicationScopeWhere`). Both groups render when both apply.
-- **Self-filter** — a row in the reviewer group for the viewer's own application is dropped; it already appears in "Your applications", and without the filter a manager or admin who applied to a position they review would see their own application twice.
-- **Newest 10 per group** — each group is independently capped at 10, newest `submittedAt` first. The filter runs after the cap, so the reviewer group can show fewer than 10 when some of the newest rows are the viewer's own.
+- **Composition** — everyone always gets **their own** non-draft applications on published positions, with public status only ([XC-8](#xc-8-applicant-facing-status-grouping)) — this covers a manager or admin who has also applied. Managers and admins additionally get a reviewer group: managed positions only for a manager, every published position for an admin, scoped the same way as [PM-8](#pm-8-work-the-application-queue)'s queue (`buildApplicationScopeWhere`). The reviewer group also carries "\<title\> was opened" / "\<title\> was reopened" items for positions in that same scope, sourced from `PositionStatusEvent` rows with `to: 'open'` (`getRecentPositionOpenings`), each linking to `/positions/[id]`; unlike applications, these get **no self-filter** — the admin who opened a position still sees it under "All positions". Both groups render when either has items.
+- **Self-filter** — a row in the reviewer group for the viewer's own **application** is dropped; it already appears in "Your applications", and without the filter a manager or admin who applied to a position they review would see their own application twice. Position-opening rows are never self-filtered.
+- **Newest 10, merged** — "Your applications" is capped at 10, newest `submittedAt` first. The reviewer group merges applications and position openings by timestamp and keeps the newest 10 **across both kinds** — an active feed can show fewer than 10 applications to make room for an opening, or vice versa. The application self-filter runs before the merge, so the reviewer group can show fewer than 10 when some of the newest application rows are the viewer's own.
 - **Group headings** — only for a viewer with a reviewer group at all. "Your applications" first, then "Positions you manage" (manager) or "All positions" (admin); a group with no items is omitted. A plain applicant (no reviewer group) sees one flat list with no heading at all.
 - **Empty** — only when every visible group is empty: "No recent activity" plus a scope-specific description ("Updates to your applications will show up here." / "…and new applications to the positions you manage will show up here." / "…and new applications across all positions will show up here.").
 - **Freshness** — the panel lives in the shared layout, so Next keeps it across client-side navigations. It refreshes on a hard load, `router.refresh()`, or any server action whose `revalidatePath`/`revalidateTag` covers the layout — not on a plain link navigation. There is no unread state, badge, or mark-as-read, so this cannot tell a manager that something changed without them opening it and reading it.
@@ -439,7 +439,7 @@ A user who manages at least one non-deleted position. Manager status is **derive
 
 - **Trigger** — **Edit** on `/positions/[id]`, or a managed position card (`/manage/positions/[id]/edit`).
 - **Happy path** — the page is a single `max-w-5xl` scroll, no tabs: one merged Details card (title, then opens/closes side by side, then description), Managers and Questions side by side, then the danger zone last. The page loads the position, then `requireListedManagerOr404` against the already-loaded managers list. Status is not a form field anywhere — it lives in the header as a badge (`PositionStatusBadge`, next to the title) plus a split-button/caret action control ([PM-3](#pm-3-create-a-position) covers create; the header actions below cover every later move). Title and description each autosave independently on blur — `updatePositionTitle`/`updatePositionDescription` — with inline **Saving…**/**Saved**/error text under the field instead of a toast (a toast per field per save would be spam); `opensAt`/`closesAt` autosave together as a pair through `updatePositionSchedule`, sharing one status line, since a single date can't be validated alone. Every autosave debounces to blur only — nothing fires mid-keystroke. Each date field shows a ghost **✕** control beside it whenever it holds a value, labeled to name its field ("Clear open date" / "Clear close date"); clicking it empties the field and commits immediately through `updatePositionSchedule`, the same as any other date edit — there is no staged, uncommitted clear. Each write revalidates the position, its detail page, the dashboard, `/applications` and `/manage/applications`, since a status flip elsewhere changes what every one of those surfaces shows.
-  - **Status transitions (header actions).** The legal targets from the current status (`getPositionTransitionTargets`) render as a split button — first target primary, the rest behind a caret — always behind a confirm dialog, since a header button has none of the deliberateness a select-then-Save had. `draft` → **Open position** is always rendered (never hidden): an admin sees it enabled; a manager sees it disabled with a tooltip, "Only an admin can open this position." `open`, no applications → **Close position** + caret → **Return to draft**; with applications, **Close position** alone. `closed` → **Reopen position** is always rendered (never hidden), disabled with a tooltip when it isn't currently legal: a manager sees it disabled with "Only an admin can reopen this position."; an admin past the close date sees it disabled with "Clear or extend Closes At to reopen this position."; an admin with `closesAt` null or in the future sees it enabled. There is no **Return to draft** from `closed` — that move no longer exists. Archived → no header actions. Toasts: **"Position opened"** / **"Position closed"** / **"Position reopened"** / **"Position returned to draft"**.
+  - **Status transitions (header actions).** The legal targets from the current status (`getPositionTransitionTargets`) render as a split button — first target primary, the rest behind a caret — always behind a confirm dialog, since a header button has none of the deliberateness a select-then-Save had. `draft` → **Open position** is always rendered (never hidden): an admin sees it enabled; a manager sees it disabled with a tooltip, "Only an admin can open this position." `open`, no applications → **Close position** + caret → **Return to draft**; with applications, **Close position** alone. `closed` → **Reopen position** is always rendered (never hidden), disabled with a tooltip when it isn't currently legal: a manager sees it disabled with "Only an admin can reopen this position."; an admin past the close date sees it disabled with "Clear or extend Closes At to reopen this position."; an admin with `closesAt` null or in the future sees it enabled. There is no **Return to draft** from `closed` — that move no longer exists. Archived → no header actions. Toasts: **"Position opened"** / **"Position closed"** / **"Position reopened"** / **"Position returned to draft"**. `updatePositionStatus` re-reads the row inside a transaction, compare-and-swaps on the exact status just read, and — for every real transition — records a `PositionStatusEvent` in the same transaction; a same-status save writes none. A `to: 'open'` event is what feeds the managers' activity-panel item ([XC-10](#xc-10-activity-panel)); it is not application activity and does not affect the archive window below.
   - **Live-edit warning.** An `open` or `closed` position — never `draft` — shows a full-width warning bar under the page title: "Changes made here are immediately visible in the live application."
 - **Failure / edge**
   - Position missing or soft-deleted → `notFound()`, checked **before** the access guard so both paths 404 identically.
@@ -450,6 +450,7 @@ A user who manages at least one non-deleted position. Manager status is **derive
   - `closed → draft`, any caller (stale tab or hand-made request — no header control ever offers it, since `POSITION_STATUS_TRANSITIONS` has no entry for it, independent of application count or `closesAt`) → `{ error: 'A closed position cannot go back to draft. Reopen it instead, or leave it closed.' }`.
   - `open → draft` once any non-deleted application exists (stale tab or a race with a concurrent first application) → `{ error: 'Someone has already started an application, so this position cannot go back to draft. Close it instead.' }`; **Return to draft** drops out of the header the moment an application exists.
   - `closed → open` with `closesAt` still in the past (stale tab, or the manager didn't clear/extend it first) → `{ error: "This position's close date has passed. Clear or extend the close date to reopen it." }`; **Reopen position** stays visible but disabled, reading the position's stored `closesAt` — never a value from the request — with the same message in its tooltip.
+  - A concurrent save changed the position's status between load and submit (the compare-and-swap's `updateMany` matches zero rows, and a re-read shows a different status than the one this request started from) → `{ error: POSITION_STATUS_CHANGED_ERROR }`: **"This position just changed. Refresh to see its current status."**
   - `opensAt` or `closesAt` **changed** to a date before today → the same past-date messages as [PM-3](#pm-3-create-a-position), checked against the position's own previous dates. An untouched past date on an already-open position saves normally — the rule only fires on a date the manager actually changed. A partially-typed date reads as empty to the form but the browser reports it as `badInput`; on blur that shows "This date is incomplete. Finish it, or use Clear to remove it." inline instead of committing, so a stray incomplete keystroke can no longer save as a silent clear — only a genuinely empty field clears. Clicking Clear on one date while the other is still incomplete reverts the click and shows "Not cleared — finish or clear the other date first." on the clicked field, since the pair only ever commits together. Clearing `closesAt` on an open position makes it accept applications indefinitely; clearing it on a closed position drops the `closesAtPast` block and re-enables **Reopen position** without a reload.
   - An empty title on blur → "Title is required" inline; nothing saves, the header keeps showing the last-saved title.
   - Deleted between render and an autosave → **"This position no longer exists."**, shown inline on the field, not a toast.
@@ -590,7 +591,7 @@ A user who manages at least one non-deleted position. Manager status is **derive
 
 ## Admin (AD)
 
-An admin is a **manager on every position**: every [Position manager](#position-manager-pm) workflow applies unchanged, with the scope widened from "positions I manage" to all of them (`buildReviewablePositionWhere`), and draft positions visible everywhere. Admins are exempt from the archived-position edit block ([PM-4](#pm-4-edit-position-details)) and from the self-removal rule ([PM-7](#pm-7-remove-a-manager)). Admins alone may set a position to `open`, from `draft` or `closed` ([PM-4](#pm-4-edit-position-details)) — publishing is a permission, not a workflow: no queue, no approve/reject, no notification back to the manager. This section covers only the admin-exclusive surfaces. The sidebar gains a **Settings** group with **Users**, **Global Questions** and **Email Log**, alongside the **Manage** group with **Manage Positions** and Applications a manager already sees ([PM intro](#position-manager-pm)). The activity panel's `all` scope follows the same widening — an admin's reviewer group covers every published position, alongside their own application activity ([XC-10](#xc-10-activity-panel)).
+An admin is a **manager on every position**: every [Position manager](#position-manager-pm) workflow applies unchanged, with the scope widened from "positions I manage" to all of them (`buildReviewablePositionWhere`), and draft positions visible everywhere. Admins are exempt from the archived-position edit block ([PM-4](#pm-4-edit-position-details)) and from the self-removal rule ([PM-7](#pm-7-remove-a-manager)). Admins alone may set a position to `open`, from `draft` or `closed` ([PM-4](#pm-4-edit-position-details)) — publishing is a permission, not a workflow: no queue, no approve/reject, and the only signal back to the manager is an activity-panel item ([XC-10](#xc-10-activity-panel)). This section covers only the admin-exclusive surfaces. The sidebar gains a **Settings** group with **Users**, **Global Questions** and **Email Log**, alongside the **Manage** group with **Manage Positions** and Applications a manager already sees ([PM intro](#position-manager-pm)). The activity panel's `all` scope follows the same widening — an admin's reviewer group covers every published position, alongside their own application activity ([XC-10](#xc-10-activity-panel)).
 
 ### AD-1 See every position
 

From c958549c0057ba510b549295111fffff234ca0d4 Mon Sep 17 00:00:00 2001
From: Ciel Bellerose <kcbellerose@icloud.com>
Date: Thu, 24 Sep 2026 18:59:09 -0400
Subject: [PATCH 28/35] #775 address review feedback

Add manual and deadline-close activity rows, and trim three
over-long comments flagged for the same discipline rule.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 docs/PERMISSIONS.md                |   2 +-
 docs/WORKFLOWS.md                  |   6 +-
 lib/constants.ts                   |   8 ++
 lib/types.ts                       |  14 +++-
 prisma/actions/position-actions.ts |   7 +-
 prisma/data/activity.ts            |  71 ++++++++++++----
 prisma/data/positions.ts           |  40 +++++++--
 tests/db/authorization.test.ts     | 125 ++++++++++++++++++++++++++++-
 8 files changed, 238 insertions(+), 35 deletions(-)

diff --git a/docs/PERMISSIONS.md b/docs/PERMISSIONS.md
index d632a1a8..ca14b5c4 100644
--- a/docs/PERMISSIONS.md
+++ b/docs/PERMISSIONS.md
@@ -138,7 +138,7 @@ Confirmations carry the risk the freezes don't.
 
 - **Archived is derived, never stored.** `isPositionActive` (`lib/utils.ts`) is the single source of truth, fed by `positionActivitySelect` / `withPositionActivity` (`prisma/data/positions.ts`). A second implementation is an authorization bug, not a display bug.
 - A position is archived once it is closed (`status: 'closed'`, or `open` past `closesAt`) for more than `MANAGED_POSITIONS_WINDOW_DAYS` **and** no application status has changed in that same window. Unresolved applications no longer pin a position active indefinitely — only recent activity does.
-- **"Activity" here means an `ApplicationStatusEvent` only.** `PositionStatusEvent` (the activity-panel "was opened"/"was reopened" item, `docs/WORKFLOWS.md` XC-10) is not read by `positionActivitySelect`/`withPositionActivity` and does not reset the archive window — reopening a position starts the clock over via its own `status`/`closesAt`, not via this event table.
+- **"Activity" here means an `ApplicationStatusEvent` only.** `PositionStatusEvent` (the activity-panel "was opened"/"was reopened"/"was closed" item, `docs/WORKFLOWS.md` XC-10) is not read by `positionActivitySelect`/`withPositionActivity` and does not reset the archive window — reopening a position starts the clock over via its own `status`/`closesAt`, not via this event table.
 - **There is no manual archive or unarchive.** A position leaves archive when an admin reopens it with a future close date, or — since a status change is itself activity — the moment a reviewer moves one of its applications, admin or not.
 - Managers are denied with `ARCHIVED_POSITION_EDIT_ERROR` (`lib/constants.ts`), returned by the four position-field actions (`updatePositionTitle`, `updatePositionDescription`, `updatePositionSchedule`, `updatePositionStatus`), the three position-question actions, and `addPositionManager`/`removePositionManager`. Admins short-circuit the check inside `checkPositionEditable` (`prisma/data/positions.ts`).
 - **The edit page does not 404.** It renders Details/Availability as read-only text, `PositionQuestionsReadonly`, and `PositionManagersReadonly` behind an explanatory callout, so a manager can still read what they can no longer change.
diff --git a/docs/WORKFLOWS.md b/docs/WORKFLOWS.md
index f85c7d4b..276d6bce 100644
--- a/docs/WORKFLOWS.md
+++ b/docs/WORKFLOWS.md
@@ -96,9 +96,9 @@ Three applicant-facing email _events_, over two rendered templates, all through
 
 A `Sheet` reachable from every authenticated page, not just the dashboard — top-right of the sidebar's `h-14` header bar on desktop, and immediately left of the hamburger menu on mobile, so the control lands in the same visual position at both breakpoints. Hidden entirely for anonymous visitors. Opens from the right (`side="right"`), so it never reads as the same surface as `MobileNav`'s `side="left"` menu drawer.
 
-- **Composition** — everyone always gets **their own** non-draft applications on published positions, with public status only ([XC-8](#xc-8-applicant-facing-status-grouping)) — this covers a manager or admin who has also applied. Managers and admins additionally get a reviewer group: managed positions only for a manager, every published position for an admin, scoped the same way as [PM-8](#pm-8-work-the-application-queue)'s queue (`buildApplicationScopeWhere`). The reviewer group also carries "\<title\> was opened" / "\<title\> was reopened" items for positions in that same scope, sourced from `PositionStatusEvent` rows with `to: 'open'` (`getRecentPositionOpenings`), each linking to `/positions/[id]`; unlike applications, these get **no self-filter** — the admin who opened a position still sees it under "All positions". Both groups render when either has items.
-- **Self-filter** — a row in the reviewer group for the viewer's own **application** is dropped; it already appears in "Your applications", and without the filter a manager or admin who applied to a position they review would see their own application twice. Position-opening rows are never self-filtered.
-- **Newest 10, merged** — "Your applications" is capped at 10, newest `submittedAt` first. The reviewer group merges applications and position openings by timestamp and keeps the newest 10 **across both kinds** — an active feed can show fewer than 10 applications to make room for an opening, or vice versa. The application self-filter runs before the merge, so the reviewer group can show fewer than 10 when some of the newest application rows are the viewer's own.
+- **Composition** — everyone always gets **their own** non-draft applications on published positions, with public status only ([XC-8](#xc-8-applicant-facing-status-grouping)) — this covers a manager or admin who has also applied. Managers and admins additionally get a reviewer group: managed positions only for a manager, every published position for an admin, scoped the same way as [PM-8](#pm-8-work-the-application-queue)'s queue (`buildApplicationScopeWhere`). The reviewer group also carries position status rows for positions in that same scope: "\<title\> was opened" / "\<title\> was reopened" / "\<title\> was closed", sourced from `PositionStatusEvent` rows with `to: 'open'` or `to: 'closed'` (`getRecentPositionStatusEvents`), plus a derived "\<title\> closed" row for an `open` position whose `closesAt` has passed with no status change — nothing runs on a schedule to write an event for that, so it's read straight off `closesAt` within `RECENTLY_CLOSED_WINDOW_DAYS` (`getRecentPositionDeadlineCloses`); a manually-closed position never also gets this derived row, since its stored status is no longer `open`. Each links to `/positions/[id]`; unlike applications, these get **no self-filter** — the admin who opened or closed a position still sees it under "All positions". Both groups render when either has items.
+- **Self-filter** — a row in the reviewer group for the viewer's own **application** is dropped; it already appears in "Your applications", and without the filter a manager or admin who applied to a position they review would see their own application twice. Position status rows (opens and closes) are never self-filtered.
+- **Newest 10, merged** — "Your applications" is capped at 10, newest `submittedAt` first. The reviewer group merges applications and position status rows by timestamp (a deadline close's timestamp is its `closesAt`) and keeps the newest 10 **across all kinds** — an active feed can show fewer than 10 applications to make room for a status row, or vice versa. The application self-filter runs before the merge, so the reviewer group can show fewer than 10 when some of the newest application rows are the viewer's own.
 - **Group headings** — only for a viewer with a reviewer group at all. "Your applications" first, then "Positions you manage" (manager) or "All positions" (admin); a group with no items is omitted. A plain applicant (no reviewer group) sees one flat list with no heading at all.
 - **Empty** — only when every visible group is empty: "No recent activity" plus a scope-specific description ("Updates to your applications will show up here." / "…and new applications to the positions you manage will show up here." / "…and new applications across all positions will show up here.").
 - **Freshness** — the panel lives in the shared layout, so Next keeps it across client-side navigations. It refreshes on a hard load, `router.refresh()`, or any server action whose `revalidatePath`/`revalidateTag` covers the layout — not on a plain link navigation. There is no unread state, badge, or mark-as-read, so this cannot tell a manager that something changed without them opening it and reading it.
diff --git a/lib/constants.ts b/lib/constants.ts
index 981293c1..d69db640 100644
--- a/lib/constants.ts
+++ b/lib/constants.ts
@@ -1153,6 +1153,14 @@ export const POSITION_ACTIVITY_SENTENCE: Record<
   closed: (title) => `${title} was reopened`,
 };
 
+// "to: closed" event copy — always from 'open', the only legal transition in.
+export const POSITION_CLOSED_SENTENCE = (title: string) =>
+  `${title} was closed`;
+
+// Derived deadline-close copy (no event, so no "was" — nothing acted on it).
+export const POSITION_CLOSED_BY_DATE_SENTENCE = (title: string) =>
+  `${title} closed`;
+
 // Order is meaningful — rendered left to right on position cards.
 export const POSITION_CARD_STAT_STATUSES = [
   'applied',
diff --git a/lib/types.ts b/lib/types.ts
index 0d88c458..1979cab1 100644
--- a/lib/types.ts
+++ b/lib/types.ts
@@ -413,8 +413,7 @@ export type QuestionFileDownload = {
 };
 
 // sentence is pre-rendered safe copy; statusVariant drives the dot color.
-// href is set only for rows that link somewhere (position openings); plain
-// application rows leave it undefined and render as static text.
+// href is set only for linkable rows (position opens/closes).
 export type ActivityItem = {
   id: string;
   statusVariant: BadgeVariant;
@@ -434,17 +433,24 @@ export type ActivityGroups = {
   reviewed: ActivityItem[];
 };
 
-// Matches getRecentPositionOpenings's select in prisma/data/positions.ts.
+// Matches getRecentPositionStatusEvents's select in prisma/data/positions.ts.
 // No actor identity selected — changedBy never reaches the activity panel.
-export type PositionOpeningActivity = Prisma.PositionStatusEventGetPayload<{
+export type PositionStatusActivity = Prisma.PositionStatusEventGetPayload<{
   select: {
     id: true;
     from: true;
+    to: true;
     createdAt: true;
     position: { select: { id: true; title: true } };
   };
 }>;
 
+// Matches getRecentPositionDeadlineCloses's select — no event backs this row,
+// so closesAt itself (guaranteed non-null by that query's where) is the timestamp.
+export type PositionDeadlineCloseActivity = Prisma.PositionGetPayload<{
+  select: { id: true; title: true; closesAt: true };
+}>;
+
 // Exposes other users' identities — admin-gated contexts only, never a non-admin client.
 export type AdminUserListItem = Prisma.UserGetPayload<{
   select: {
diff --git a/prisma/actions/position-actions.ts b/prisma/actions/position-actions.ts
index bbaad20c..e2b714a0 100644
--- a/prisma/actions/position-actions.ts
+++ b/prisma/actions/position-actions.ts
@@ -274,11 +274,8 @@ export async function updatePositionStatus(
   );
   if (transitionError) return { error: transitionError };
 
-  // Folded into the where (not a separate count) so a concurrent first
-  // application, or a concurrent status change, can't slip past the checks
-  // above — same shape as deletePosition. status: existing.status is a
-  // compare-and-swap: it makes the event's `from` provably the replaced
-  // status, and stops a concurrent double-open from writing two events.
+  // status: existing.status is the CAS — a concurrent status change can't
+  // slip past, and can't double-write the event.
   const updateCount = await prisma.$transaction(async (tx) => {
     const updateResult = await tx.position.updateMany({
       where: {
diff --git a/prisma/data/activity.ts b/prisma/data/activity.ts
index 425540f7..a55b2404 100644
--- a/prisma/data/activity.ts
+++ b/prisma/data/activity.ts
@@ -7,12 +7,17 @@ import {
   getRecentApplications,
 } from '@/prisma/data/applications';
 import { isManager } from '@/prisma/data/managers';
-import { getRecentPositionOpenings } from '@/prisma/data/positions';
+import {
+  getRecentPositionDeadlineCloses,
+  getRecentPositionStatusEvents,
+} from '@/prisma/data/positions';
 
 import {
   APPLICATION_STATUS_BADGE_VARIANT,
   APPLICATION_STATUS_LABELS,
   POSITION_ACTIVITY_SENTENCE,
+  POSITION_CLOSED_BY_DATE_SENTENCE,
+  POSITION_CLOSED_SENTENCE,
   POSITION_STATUS_BADGE_VARIANT,
 } from '@/lib/constants';
 import { type ActivityGroups, type ActivityItem } from '@/lib/types';
@@ -31,15 +36,22 @@ export const getActivityGroups = cache(async function getActivityGroups(
       ? 'managed'
       : 'none';
 
-  const [applications, reviewed, openings] = await Promise.all([
-    getMyRecentActivity(userId, ACTIVITY_TAKE),
-    scope !== 'none'
-      ? getRecentApplications({ id: userId, isAdmin }, ACTIVITY_TAKE)
-      : Promise.resolve([]),
-    scope !== 'none'
-      ? getRecentPositionOpenings({ id: userId, isAdmin }, ACTIVITY_TAKE)
-      : Promise.resolve([]),
-  ]);
+  const [applications, reviewed, statusEvents, deadlineCloses] =
+    await Promise.all([
+      getMyRecentActivity(userId, ACTIVITY_TAKE),
+      scope !== 'none'
+        ? getRecentApplications({ id: userId, isAdmin }, ACTIVITY_TAKE)
+        : Promise.resolve([]),
+      scope !== 'none'
+        ? getRecentPositionStatusEvents({ id: userId, isAdmin }, ACTIVITY_TAKE)
+        : Promise.resolve([]),
+      scope !== 'none'
+        ? getRecentPositionDeadlineCloses(
+            { id: userId, isAdmin },
+            ACTIVITY_TAKE,
+          )
+        : Promise.resolve([]),
+    ]);
 
   const mine: ActivityItem[] = applications.map((app) => {
     const statusLabel = APPLICATION_STATUS_LABELS[app.status];
@@ -67,10 +79,12 @@ export const getActivityGroups = cache(async function getActivityGroups(
     });
 
   // to: 'open' means from can never be 'open' — narrow with a guard, not a cast.
-  const openingItems: ActivityItem[] = openings
+  const openingItems: ActivityItem[] = statusEvents
     .filter(
-      (event): event is typeof event & { from: 'draft' | 'closed' } =>
-        event.from !== 'open',
+      (
+        event,
+      ): event is typeof event & { to: 'open'; from: 'draft' | 'closed' } =>
+        event.to === 'open',
     )
     .map((event) => ({
       id: event.id,
@@ -80,7 +94,36 @@ export const getActivityGroups = cache(async function getActivityGroups(
       href: `/positions/${event.position.id}`,
     }));
 
-  const reviewedItems = [...applicationItems, ...openingItems]
+  const closedItems: ActivityItem[] = statusEvents
+    .filter((event) => event.to === 'closed')
+    .map((event) => ({
+      id: event.id,
+      statusVariant: POSITION_STATUS_BADGE_VARIANT.closed,
+      sentence: POSITION_CLOSED_SENTENCE(event.position.title),
+      timestamp: event.createdAt,
+      href: `/positions/${event.position.id}`,
+    }));
+
+  // closesAt is guaranteed non-null by the query's where — narrow, not cast.
+  const deadlineCloseItems: ActivityItem[] = deadlineCloses
+    .filter(
+      (position): position is typeof position & { closesAt: Date } =>
+        position.closesAt !== null,
+    )
+    .map((position) => ({
+      id: `deadline-close-${position.id}`,
+      statusVariant: POSITION_STATUS_BADGE_VARIANT.closed,
+      sentence: POSITION_CLOSED_BY_DATE_SENTENCE(position.title),
+      timestamp: position.closesAt,
+      href: `/positions/${position.id}`,
+    }));
+
+  const reviewedItems = [
+    ...applicationItems,
+    ...openingItems,
+    ...closedItems,
+    ...deadlineCloseItems,
+  ]
     .sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime())
     .slice(0, ACTIVITY_TAKE);
 
diff --git a/prisma/data/positions.ts b/prisma/data/positions.ts
index e001dd57..3d0afb81 100644
--- a/prisma/data/positions.ts
+++ b/prisma/data/positions.ts
@@ -15,10 +15,11 @@ import {
   type ManagedPosition,
   type ManagedPositionSummaryItem,
   type OpenPositionSummaryItem,
+  type PositionDeadlineCloseActivity,
   type PositionDeletionSummary,
   type PositionDetail,
   type PositionForEdit,
-  type PositionOpeningActivity,
+  type PositionStatusActivity,
   type PositionWithQuestions,
   type Reviewer,
 } from '@/lib/types';
@@ -382,18 +383,20 @@ export async function getPositionDeletionSummary(
   return { submittedCount, draftCount };
 }
 
-// Feeds the activity panel's reviewer group — scoped identically to
-// getRecentApplications, so a position leaving the reviewer's scope (returned
-// to draft, or the reviewer no longer manages it) drops its opening out too.
-export async function getRecentPositionOpenings(
+// Scoped identically to getRecentApplications so drift can't desync the two feeds.
+export async function getRecentPositionStatusEvents(
   reviewer: Reviewer,
   take: number,
-): Promise<PositionOpeningActivity[]> {
+): Promise<PositionStatusActivity[]> {
   return prisma.positionStatusEvent.findMany({
-    where: { to: 'open', position: buildReviewablePositionWhere(reviewer) },
+    where: {
+      to: { in: ['open', 'closed'] },
+      position: buildReviewablePositionWhere(reviewer),
+    },
     select: {
       id: true,
       from: true,
+      to: true,
       createdAt: true,
       position: { select: { id: true, title: true } },
     },
@@ -401,3 +404,26 @@ export async function getRecentPositionOpenings(
     take,
   });
 }
+
+// No PositionStatusEvent exists for a deadline lapse — nothing runs on a
+// schedule to write one — so this reads closesAt straight off an open position.
+// status: 'open' also keeps a manually-closed position from double-reporting.
+export async function getRecentPositionDeadlineCloses(
+  reviewer: Reviewer,
+  take: number,
+): Promise<PositionDeadlineCloseActivity[]> {
+  const now = new Date();
+  const cutoff = new Date(now);
+  cutoff.setDate(cutoff.getDate() - RECENTLY_CLOSED_WINDOW_DAYS);
+
+  return prisma.position.findMany({
+    where: {
+      ...buildReviewablePositionWhere(reviewer),
+      status: 'open',
+      closesAt: { gte: cutoff, lte: now },
+    },
+    select: { id: true, title: true, closesAt: true },
+    orderBy: [{ closesAt: 'desc' }, { id: 'desc' }],
+    take,
+  });
+}
diff --git a/tests/db/authorization.test.ts b/tests/db/authorization.test.ts
index f128adf1..dfa6c2c8 100644
--- a/tests/db/authorization.test.ts
+++ b/tests/db/authorization.test.ts
@@ -1012,7 +1012,7 @@ describe('getActivityGroups composition and scoping', () => {
     expect(sentences).toContain(`${position.title} was opened`);
   });
 
-  it('reopening (open -> closed -> open) shows "was reopened"; the close produces no item', async () => {
+  it('reopening (open -> closed -> open) shows both "was closed" and "was reopened"', async () => {
     const manager = await createTestUser();
     const position = await createTestPosition(admin, {
       managers: [manager],
@@ -1026,9 +1026,132 @@ describe('getActivityGroups composition and scoping', () => {
     const groups = await getActivityGroups(manager.id, false);
     const sentences = groups.reviewed.map((i) => i.sentence);
     expect(sentences).toContain(`${position.title} was reopened`);
+    expect(sentences).toContain(`${position.title} was closed`);
+  });
+
+  it('manual close: the listed manager sees a "was closed" item linking to the position', async () => {
+    const manager = await createTestUser();
+    const position = await createTestPosition(admin, {
+      managers: [manager],
+      status: 'open',
+    });
+
+    actAs(admin);
+    const result = await updatePositionStatus({
+      id: position.id,
+      status: 'closed',
+    });
+    expect(result).toBeUndefined();
+
+    const groups = await getActivityGroups(manager.id, false);
+    const item = groups.reviewed.find((i) =>
+      i.sentence.includes(position.title),
+    );
+    expect(item).toBeDefined();
+    expect(item?.sentence).toBe(`${position.title} was closed`);
+    expect(item?.href).toBe(`/positions/${position.id}`);
+  });
+
+  it('a manager of a different position does not see the close', async () => {
+    const manager = await createTestUser();
+    const otherManager = await createTestUser();
+    const position = await createTestPosition(admin, {
+      managers: [manager],
+      status: 'open',
+    });
+
+    actAs(admin);
+    await updatePositionStatus({ id: position.id, status: 'closed' });
+
+    const groups = await getActivityGroups(otherManager.id, false);
+    const sentences = groups.reviewed.map((i) => i.sentence);
     expect(sentences).not.toContain(`${position.title} was closed`);
   });
 
+  it('an applicant on the position never sees the close', async () => {
+    const manager = await createTestUser();
+    const position = await createTestPosition(admin, {
+      managers: [manager],
+      status: 'open',
+    });
+    const positionApplicant = await createTestUser();
+    await createTestApplication(positionApplicant, position, {
+      status: 'applied',
+    });
+
+    actAs(admin);
+    await updatePositionStatus({ id: position.id, status: 'closed' });
+
+    const groups = await getActivityGroups(positionApplicant.id, false);
+    expect(groups.scope).toBe('none');
+    expect(groups.reviewed).toEqual([]);
+  });
+
+  it('deadline close: an open position past closesAt shows a derived "closed" item with no "was"', async () => {
+    const manager = await createTestUser();
+    const past = new Date(Date.now() - 60 * 60 * 1000);
+    const position = await createTestPosition(admin, {
+      managers: [manager],
+      status: 'open',
+      closesAt: past,
+    });
+
+    const groups = await getActivityGroups(manager.id, false);
+    const item = groups.reviewed.find((i) =>
+      i.sentence.includes(position.title),
+    );
+    expect(item).toBeDefined();
+    expect(item?.sentence).toBe(`${position.title} closed`);
+    expect(item?.href).toBe(`/positions/${position.id}`);
+  });
+
+  it('deadline close: scoped like other rows — a different manager and an applicant never see it', async () => {
+    const manager = await createTestUser();
+    const otherManager = await createTestUser();
+    const past = new Date(Date.now() - 60 * 60 * 1000);
+    const position = await createTestPosition(admin, {
+      managers: [manager],
+      status: 'open',
+      closesAt: past,
+    });
+    const positionApplicant = await createTestUser();
+    await createTestApplication(positionApplicant, position, {
+      status: 'applied',
+    });
+
+    const otherGroups = await getActivityGroups(otherManager.id, false);
+    expect(otherGroups.reviewed.map((i) => i.sentence)).not.toContain(
+      `${position.title} closed`,
+    );
+
+    const applicantGroups = await getActivityGroups(
+      positionApplicant.id,
+      false,
+    );
+    expect(applicantGroups.scope).toBe('none');
+    expect(applicantGroups.reviewed).toEqual([]);
+  });
+
+  it('no duplicates: a manually-closed position never also gets the derived deadline-close row', async () => {
+    const manager = await createTestUser();
+    const past = new Date(Date.now() - 60 * 60 * 1000);
+    const position = await createTestPosition(admin, {
+      managers: [manager],
+      status: 'open',
+      closesAt: past,
+    });
+
+    actAs(admin);
+    await updatePositionStatus({ id: position.id, status: 'closed' });
+
+    const groups = await getActivityGroups(manager.id, false);
+    const matching = groups.reviewed.filter((i) =>
+      i.sentence.includes(position.title),
+    );
+    expect(matching).toHaveLength(1);
+    expect(matching[0]?.sentence).toBe(`${position.title} was closed`);
+  });
+
   it('returning to draft after opening drops the item for the manager', async () => {
     const manager = await createTestUser();
     const position = await createTestPosition(admin, {

From 37a975d26d32557f743c90485fd25c96e94b87bc Mon Sep 17 00:00:00 2001
From: Ciel Bellerose <kcbellerose@icloud.com>
Date: Thu, 24 Sep 2026 19:21:28 -0400
Subject: [PATCH 29/35] #775 address review feedback

Adds the deletion row for the activity panel (R3-M1, second amendment
in #775): a published position deleted while open/closed shows an
unlinked "was deleted" item, derived from deletedAt with no schema
change. Fixes the scope gap where deleting a manager's only position
would drop their reviewer group before the notification could show.
Also compresses the deadline-close comment flagged as R3-L1.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 docs/WORKFLOWS.md              |  8 ++--
 lib/auth/scopes.ts             |  9 ++++
 lib/constants.ts               |  3 ++
 lib/types.ts                   |  6 +++
 prisma/data/activity.ts        | 54 +++++++++++++++-------
 prisma/data/positions.ts       | 24 ++++++++--
 tests/db/authorization.test.ts | 84 ++++++++++++++++++++++++++++++++++
 7 files changed, 163 insertions(+), 25 deletions(-)

diff --git a/docs/WORKFLOWS.md b/docs/WORKFLOWS.md
index 276d6bce..779a4522 100644
--- a/docs/WORKFLOWS.md
+++ b/docs/WORKFLOWS.md
@@ -96,9 +96,9 @@ Three applicant-facing email _events_, over two rendered templates, all through
 
 A `Sheet` reachable from every authenticated page, not just the dashboard — top-right of the sidebar's `h-14` header bar on desktop, and immediately left of the hamburger menu on mobile, so the control lands in the same visual position at both breakpoints. Hidden entirely for anonymous visitors. Opens from the right (`side="right"`), so it never reads as the same surface as `MobileNav`'s `side="left"` menu drawer.
 
-- **Composition** — everyone always gets **their own** non-draft applications on published positions, with public status only ([XC-8](#xc-8-applicant-facing-status-grouping)) — this covers a manager or admin who has also applied. Managers and admins additionally get a reviewer group: managed positions only for a manager, every published position for an admin, scoped the same way as [PM-8](#pm-8-work-the-application-queue)'s queue (`buildApplicationScopeWhere`). The reviewer group also carries position status rows for positions in that same scope: "\<title\> was opened" / "\<title\> was reopened" / "\<title\> was closed", sourced from `PositionStatusEvent` rows with `to: 'open'` or `to: 'closed'` (`getRecentPositionStatusEvents`), plus a derived "\<title\> closed" row for an `open` position whose `closesAt` has passed with no status change — nothing runs on a schedule to write an event for that, so it's read straight off `closesAt` within `RECENTLY_CLOSED_WINDOW_DAYS` (`getRecentPositionDeadlineCloses`); a manually-closed position never also gets this derived row, since its stored status is no longer `open`. Each links to `/positions/[id]`; unlike applications, these get **no self-filter** — the admin who opened or closed a position still sees it under "All positions". Both groups render when either has items.
-- **Self-filter** — a row in the reviewer group for the viewer's own **application** is dropped; it already appears in "Your applications", and without the filter a manager or admin who applied to a position they review would see their own application twice. Position status rows (opens and closes) are never self-filtered.
-- **Newest 10, merged** — "Your applications" is capped at 10, newest `submittedAt` first. The reviewer group merges applications and position status rows by timestamp (a deadline close's timestamp is its `closesAt`) and keeps the newest 10 **across all kinds** — an active feed can show fewer than 10 applications to make room for a status row, or vice versa. The application self-filter runs before the merge, so the reviewer group can show fewer than 10 when some of the newest application rows are the viewer's own.
+- **Composition** — everyone always gets **their own** non-draft applications on published positions, with public status only ([XC-8](#xc-8-applicant-facing-status-grouping)) — this covers a manager or admin who has also applied. Managers and admins additionally get a reviewer group: managed positions only for a manager, every published position for an admin, scoped the same way as [PM-8](#pm-8-work-the-application-queue)'s queue (`buildApplicationScopeWhere`). A manager whose only position was just deleted still counts as having a reviewer group for this — `isManager` alone would say otherwise, since it only counts non-deleted positions — so `getActivityGroups` also unlocks it from a non-empty deletion row. The reviewer group also carries position status rows for positions in that same scope: "\<title\> was opened" / "\<title\> was reopened" / "\<title\> was closed", sourced from `PositionStatusEvent` rows with `to: 'open'` or `to: 'closed'` (`getRecentPositionStatusEvents`), plus a derived "\<title\> closed" row for an `open` position whose `closesAt` has passed with no status change — nothing runs on a schedule to write an event for that, so it's read straight off `closesAt` within `RECENTLY_CLOSED_WINDOW_DAYS` (`getRecentPositionDeadlineCloses`); a manually-closed position never also gets this derived row, since its stored status is no longer `open`. A position deleted while `open` or `closed` (not `draft`) also gets a row, "\<title\> was deleted", read straight off `deletedAt` (`getRecentPositionDeletions`, `buildDeletedPositionWhere`) — the only reviewer-group row not linked, since the position page no longer exists; a deleted position's earlier opened/closed/deadline-close rows drop out, because those queries already require `deletedAt: null`. Every other row links to `/positions/[id]`; unlike applications, none of these position rows get a **self-filter** — the admin who opened, closed or deleted a position still sees it under "All positions". Both groups render when either has items.
+- **Self-filter** — a row in the reviewer group for the viewer's own **application** is dropped; it already appears in "Your applications", and without the filter a manager or admin who applied to a position they review would see their own application twice. Position status rows (opens, closes and deletions) are never self-filtered.
+- **Newest 10, merged** — "Your applications" is capped at 10, newest `submittedAt` first. The reviewer group merges applications and position status rows by timestamp (a deadline close's timestamp is its `closesAt`; a deletion's is its `deletedAt`) and keeps the newest 10 **across all kinds** — an active feed can show fewer than 10 applications to make room for a status row, or vice versa. The application self-filter runs before the merge, so the reviewer group can show fewer than 10 when some of the newest application rows are the viewer's own.
 - **Group headings** — only for a viewer with a reviewer group at all. "Your applications" first, then "Positions you manage" (manager) or "All positions" (admin); a group with no items is omitted. A plain applicant (no reviewer group) sees one flat list with no heading at all.
 - **Empty** — only when every visible group is empty: "No recent activity" plus a scope-specific description ("Updates to your applications will show up here." / "…and new applications to the positions you manage will show up here." / "…and new applications across all positions will show up here.").
 - **Freshness** — the panel lives in the shared layout, so Next keeps it across client-side navigations. It refreshes on a hard load, `router.refresh()`, or any server action whose `revalidatePath`/`revalidateTag` covers the layout — not on a plain link navigation. There is no unread state, badge, or mark-as-read, so this cannot tell a manager that something changed without them opening it and reading it.
@@ -612,7 +612,7 @@ An admin is a **manager on every position**: every [Position manager](#position-
 ### AD-3 Delete a position
 
 - **Trigger** — the Delete Position card at the bottom of `/manage/positions/[id]/edit`, rendered only for admins.
-- **Happy path** — the card states "Deleting hides this position everywhere — the positions list, search results and any direct link. This can't be undone from the app." The confirmation names the position and, when relevant, adds "N unsubmitted draft applications will disappear too." `deletePosition` soft-deletes with the blocking condition folded into the `where`, so the check and the write are one atomic statement. Toast **"Position deleted"**.
+- **Happy path** — the card states "Deleting hides this position everywhere — the positions list, search results and any direct link. This can't be undone from the app." The confirmation names the position and, when relevant, adds "N unsubmitted draft applications will disappear too." `deletePosition` soft-deletes with the blocking condition folded into the `where`, so the check and the write are one atomic statement. Toast **"Position deleted"**. Deleting a position that was `open` or `closed` (not `draft`) is the only signal back to its managers — an unlinked "\<title\> was deleted" activity-panel item, derived from `deletedAt` ([XC-10](#xc-10-activity-panel)); a deleted draft produces no row.
 - **Failure / edge**
   - Any non-draft application exists → the button is disabled, and a stale tab that posts anyway gets `POSITION_DELETE_BLOCKED_ERROR`: **"This position has applications, so it can't be deleted. Close it instead."**
   - Already deleted → **"This position no longer exists."**
diff --git a/lib/auth/scopes.ts b/lib/auth/scopes.ts
index f72f9c30..981f8f29 100644
--- a/lib/auth/scopes.ts
+++ b/lib/auth/scopes.ts
@@ -17,6 +17,15 @@ export function buildReviewablePositionWhere(
     : { ...PUBLISHED_POSITION_WHERE, managers: { some: { id: user.id } } };
 }
 
+// Same admin/manager split as buildReviewablePositionWhere, but for the deleted
+// rows PUBLISHED_POSITION_WHERE always excludes.
+export function buildDeletedPositionWhere(
+  user: Reviewer,
+): Prisma.PositionWhereInput {
+  const base = { deletedAt: { not: null }, status: { not: 'draft' } } as const;
+  return user.isAdmin ? base : { ...base, managers: { some: { id: user.id } } };
+}
+
 // `status` omitted so a caller's own filter can't overwrite the position scoping.
 export function buildApplicationScopeWhere(
   user: Reviewer,
diff --git a/lib/constants.ts b/lib/constants.ts
index d69db640..7f57703b 100644
--- a/lib/constants.ts
+++ b/lib/constants.ts
@@ -1161,6 +1161,9 @@ export const POSITION_CLOSED_SENTENCE = (title: string) =>
 export const POSITION_CLOSED_BY_DATE_SENTENCE = (title: string) =>
   `${title} closed`;
 
+export const POSITION_DELETED_SENTENCE = (title: string) =>
+  `${title} was deleted`;
+
 // Order is meaningful — rendered left to right on position cards.
 export const POSITION_CARD_STAT_STATUSES = [
   'applied',
diff --git a/lib/types.ts b/lib/types.ts
index 1979cab1..09ea9a7d 100644
--- a/lib/types.ts
+++ b/lib/types.ts
@@ -451,6 +451,12 @@ export type PositionDeadlineCloseActivity = Prisma.PositionGetPayload<{
   select: { id: true; title: true; closesAt: true };
 }>;
 
+// Matches getRecentPositionDeletions's select — no event backs this row either,
+// so deletedAt (guaranteed non-null by that query's where) is the timestamp.
+export type PositionDeletionActivity = Prisma.PositionGetPayload<{
+  select: { id: true; title: true; deletedAt: true };
+}>;
+
 // Exposes other users' identities — admin-gated contexts only, never a non-admin client.
 export type AdminUserListItem = Prisma.UserGetPayload<{
   select: {
diff --git a/prisma/data/activity.ts b/prisma/data/activity.ts
index a55b2404..950f822e 100644
--- a/prisma/data/activity.ts
+++ b/prisma/data/activity.ts
@@ -9,6 +9,7 @@ import {
 import { isManager } from '@/prisma/data/managers';
 import {
   getRecentPositionDeadlineCloses,
+  getRecentPositionDeletions,
   getRecentPositionStatusEvents,
 } from '@/prisma/data/positions';
 
@@ -18,6 +19,7 @@ import {
   POSITION_ACTIVITY_SENTENCE,
   POSITION_CLOSED_BY_DATE_SENTENCE,
   POSITION_CLOSED_SENTENCE,
+  POSITION_DELETED_SENTENCE,
   POSITION_STATUS_BADGE_VARIANT,
 } from '@/lib/constants';
 import { type ActivityGroups, type ActivityItem } from '@/lib/types';
@@ -30,28 +32,31 @@ export const getActivityGroups = cache(async function getActivityGroups(
   userId: string,
   isAdmin: boolean,
 ): Promise<ActivityGroups> {
+  // Fetched unconditionally: deleting a manager's only position drops it from
+  // isManager's non-deleted count, so this alone must still unlock 'managed'.
+  const [applications, isUserManager, deletions] = await Promise.all([
+    getMyRecentActivity(userId, ACTIVITY_TAKE),
+    isAdmin ? Promise.resolve(true) : isManager(userId),
+    getRecentPositionDeletions({ id: userId, isAdmin }, ACTIVITY_TAKE),
+  ]);
+
   const scope = isAdmin
     ? 'all'
-    : (await isManager(userId))
+    : isUserManager || deletions.length > 0
       ? 'managed'
       : 'none';
 
-  const [applications, reviewed, statusEvents, deadlineCloses] =
-    await Promise.all([
-      getMyRecentActivity(userId, ACTIVITY_TAKE),
-      scope !== 'none'
-        ? getRecentApplications({ id: userId, isAdmin }, ACTIVITY_TAKE)
-        : Promise.resolve([]),
-      scope !== 'none'
-        ? getRecentPositionStatusEvents({ id: userId, isAdmin }, ACTIVITY_TAKE)
-        : Promise.resolve([]),
-      scope !== 'none'
-        ? getRecentPositionDeadlineCloses(
-            { id: userId, isAdmin },
-            ACTIVITY_TAKE,
-          )
-        : Promise.resolve([]),
-    ]);
+  const [reviewed, statusEvents, deadlineCloses] = await Promise.all([
+    scope !== 'none'
+      ? getRecentApplications({ id: userId, isAdmin }, ACTIVITY_TAKE)
+      : Promise.resolve([]),
+    scope !== 'none'
+      ? getRecentPositionStatusEvents({ id: userId, isAdmin }, ACTIVITY_TAKE)
+      : Promise.resolve([]),
+    scope !== 'none'
+      ? getRecentPositionDeadlineCloses({ id: userId, isAdmin }, ACTIVITY_TAKE)
+      : Promise.resolve([]),
+  ]);
 
   const mine: ActivityItem[] = applications.map((app) => {
     const statusLabel = APPLICATION_STATUS_LABELS[app.status];
@@ -118,11 +123,26 @@ export const getActivityGroups = cache(async function getActivityGroups(
       href: `/positions/${position.id}`,
     }));
 
+  // deletedAt is guaranteed non-null by the query's where — narrow, not cast.
+  // Not linked — the position page no longer exists.
+  const deletionItems: ActivityItem[] = deletions
+    .filter(
+      (position): position is typeof position & { deletedAt: Date } =>
+        position.deletedAt !== null,
+    )
+    .map((position) => ({
+      id: `deletion-${position.id}`,
+      statusVariant: 'destructive',
+      sentence: POSITION_DELETED_SENTENCE(position.title),
+      timestamp: position.deletedAt,
+    }));
+
   const reviewedItems = [
     ...applicationItems,
     ...openingItems,
     ...closedItems,
     ...deadlineCloseItems,
+    ...deletionItems,
   ]
     .sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime())
     .slice(0, ACTIVITY_TAKE);
diff --git a/prisma/data/positions.ts b/prisma/data/positions.ts
index 3d0afb81..a3448414 100644
--- a/prisma/data/positions.ts
+++ b/prisma/data/positions.ts
@@ -2,7 +2,10 @@ import 'server-only';
 
 import { cache } from 'react';
 
-import { buildReviewablePositionWhere } from '@/lib/auth/scopes';
+import {
+  buildDeletedPositionWhere,
+  buildReviewablePositionWhere,
+} from '@/lib/auth/scopes';
 import {
   MANAGED_POSITIONS_WINDOW_DAYS,
   NON_REVIEWABLE_APPLICATION_STATUSES,
@@ -16,6 +19,7 @@ import {
   type ManagedPositionSummaryItem,
   type OpenPositionSummaryItem,
   type PositionDeadlineCloseActivity,
+  type PositionDeletionActivity,
   type PositionDeletionSummary,
   type PositionDetail,
   type PositionForEdit,
@@ -405,9 +409,7 @@ export async function getRecentPositionStatusEvents(
   });
 }
 
-// No PositionStatusEvent exists for a deadline lapse — nothing runs on a
-// schedule to write one — so this reads closesAt straight off an open position.
-// status: 'open' also keeps a manually-closed position from double-reporting.
+// No event backs a deadline lapse, so this derives from closesAt; status: 'open' excludes a manually-closed position from double-reporting.
 export async function getRecentPositionDeadlineCloses(
   reviewer: Reviewer,
   take: number,
@@ -427,3 +429,17 @@ export async function getRecentPositionDeadlineCloses(
     take,
   });
 }
+
+// buildDeletedPositionWhere, not buildReviewablePositionWhere, since these
+// rows are excluded by the latter's deletedAt: null.
+export async function getRecentPositionDeletions(
+  reviewer: Reviewer,
+  take: number,
+): Promise<PositionDeletionActivity[]> {
+  return prisma.position.findMany({
+    where: buildDeletedPositionWhere(reviewer),
+    select: { id: true, title: true, deletedAt: true },
+    orderBy: [{ deletedAt: 'desc' }, { id: 'desc' }],
+    take,
+  });
+}
diff --git a/tests/db/authorization.test.ts b/tests/db/authorization.test.ts
index dfa6c2c8..8f1fb8d4 100644
--- a/tests/db/authorization.test.ts
+++ b/tests/db/authorization.test.ts
@@ -21,6 +21,7 @@ import {
   updateGlobalQuestion,
 } from '@/prisma/actions/global-questions';
 import {
+  deletePosition,
   searchUsers,
   updatePositionStatus,
 } from '@/prisma/actions/position-actions';
@@ -1168,6 +1169,89 @@ describe('getActivityGroups composition and scoping', () => {
     expect(sentences).not.toContain(`${position.title} was opened`);
   });
 
+  it('deletion of a published position: the listed manager sees an unlinked "was deleted" item', async () => {
+    const manager = await createTestUser();
+    const position = await createTestPosition(admin, {
+      managers: [manager],
+      status: 'open',
+    });
+
+    actAs(admin);
+    const result = await deletePosition({ id: position.id });
+    expect(result).toBeUndefined();
+
+    const groups = await getActivityGroups(manager.id, false);
+    const item = groups.reviewed.find((i) =>
+      i.sentence.includes(position.title),
+    );
+    expect(item).toBeDefined();
+    expect(item?.sentence).toBe(`${position.title} was deleted`);
+    expect(item?.href).toBeUndefined();
+  });
+
+  it('deletion of a draft position produces no row', async () => {
+    const manager = await createTestUser();
+    const position = await createTestPosition(admin, {
+      managers: [manager],
+      status: 'draft',
+    });
+
+    actAs(admin);
+    await deletePosition({ id: position.id });
+
+    const groups = await getActivityGroups(manager.id, false);
+    const sentences = groups.reviewed.map((i) => i.sentence);
+    expect(sentences).not.toContain(`${position.title} was deleted`);
+  });
+
+  it('deletion: scoped like other rows — a different manager and an applicant never see it', async () => {
+    const manager = await createTestUser();
+    const otherManager = await createTestUser();
+    const position = await createTestPosition(admin, {
+      managers: [manager],
+      status: 'closed',
+    });
+    const positionApplicant = await createTestUser();
+    await createTestApplication(positionApplicant, position, {
+      status: 'draft',
+    });
+
+    actAs(admin);
+    const deleteResult = await deletePosition({ id: position.id });
+    expect(deleteResult).toBeUndefined();
+
+    const otherGroups = await getActivityGroups(otherManager.id, false);
+    expect(otherGroups.reviewed.map((i) => i.sentence)).not.toContain(
+      `${position.title} was deleted`,
+    );
+
+    const applicantGroups = await getActivityGroups(
+      positionApplicant.id,
+      false,
+    );
+    expect(applicantGroups.reviewed.map((i) => i.sentence)).not.toContain(
+      `${position.title} was deleted`,
+    );
+  });
+
+  it('deletion: an admin sees it under "all", and the earlier opening drops out', async () => {
+    const manager = await createTestUser();
+    const position = await createTestPosition(admin, {
+      managers: [manager],
+      status: 'draft',
+    });
+
+    actAs(admin);
+    await updatePositionStatus({ id: position.id, status: 'open' });
+    await deletePosition({ id: position.id });
+
+    const groups = await getActivityGroups(admin.id, true);
+    expect(groups.scope).toBe('all');
+    const sentences = groups.reviewed.map((i) => i.sentence);
+    expect(sentences).toContain(`${position.title} was deleted`);
+    expect(sentences).not.toContain(`${position.title} was opened`);
+  });
+
   it('merges openings with applications by time and caps the combined feed at 10', async () => {
     const manager = await createTestUser();
     const position = await createTestPosition(admin, {

From 01b41ad5e73a7d887c12526f89b4cbcea04c8c8a Mon Sep 17 00:00:00 2001
From: Ciel Bellerose <kcbellerose@icloud.com>
Date: Thu, 24 Sep 2026 19:29:54 -0400
Subject: [PATCH 30/35] #645 stamp User.lastLoginAt on sign-in

Stored on User because sessions are hard-deleted on sign-out, expiry,
and deactivation, so nothing derived from Session survives long enough
to answer "who has gone quiet". The write moves into the session
create `after` hook so a blocked (deactivated) sign-in never stamps it.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 lib/auth/config.ts                            | 22 +++--
 lib/auth/session-hooks.ts                     | 28 +++++++
 .../migration.sql                             |  2 +
 prisma/schema.prisma                          |  1 +
 tests/db/last-sign-in.test.ts                 | 84 +++++++++++++++++++
 5 files changed, 125 insertions(+), 12 deletions(-)
 create mode 100644 lib/auth/session-hooks.ts
 create mode 100644 prisma/migrations/20260924232626_add_user_last_login_at/migration.sql
 create mode 100644 tests/db/last-sign-in.test.ts

diff --git a/lib/auth/config.ts b/lib/auth/config.ts
index 64e37238..f02b0441 100644
--- a/lib/auth/config.ts
+++ b/lib/auth/config.ts
@@ -4,12 +4,14 @@ import { nextCookies } from 'better-auth/next-js';
 
 import { prismaAdapter } from '@better-auth/prisma-adapter';
 import { betterAuth } from 'better-auth';
-import { APIError } from 'better-auth/api';
 import { emailOTP } from 'better-auth/plugins';
 
 import { buildOtpSignInUrl } from '@/lib/auth/otp-link';
+import {
+  assertSessionUserActive,
+  recordSignIn,
+} from '@/lib/auth/session-hooks';
 import { getBaseUrl } from '@/lib/base-url';
-import { ACCOUNT_DEACTIVATED_ERROR_CODE } from '@/lib/constants';
 import { sendEmail } from '@/lib/email/resend';
 import { otpEmail } from '@/lib/email/templates';
 import { prisma } from '@/lib/prisma';
@@ -62,17 +64,13 @@ export const auth = betterAuth({
     },
     session: {
       create: {
-        // Throws — returning false leaves callers dereferencing a null session's .token.
         before: async (session) => {
-          const user = await prisma.user.findUnique({
-            where: { id: session.userId },
-            select: { deletedAt: true },
-          });
-          if (user?.deletedAt)
-            throw APIError.from('FORBIDDEN', {
-              code: ACCOUNT_DEACTIVATED_ERROR_CODE,
-              message: 'This account has been deactivated.',
-            });
+          await assertSessionUserActive(session.userId);
+        },
+        // A blocked (before-thrown) sign-in never reaches after, so this only
+        // stamps committed sessions.
+        after: async (session) => {
+          await recordSignIn(session.userId);
         },
       },
     },
diff --git a/lib/auth/session-hooks.ts b/lib/auth/session-hooks.ts
new file mode 100644
index 00000000..2e6528e2
--- /dev/null
+++ b/lib/auth/session-hooks.ts
@@ -0,0 +1,28 @@
+import 'server-only';
+
+import { APIError } from 'better-auth/api';
+
+import { ACCOUNT_DEACTIVATED_ERROR_CODE } from '@/lib/constants';
+import { prisma } from '@/lib/prisma';
+
+// Throws — returning false leaves callers dereferencing a null session's .token.
+export async function assertSessionUserActive(userId: string): Promise<void> {
+  const user = await prisma.user.findUnique({
+    where: { id: userId },
+    select: { deletedAt: true },
+  });
+  if (user?.deletedAt)
+    throw APIError.from('FORBIDDEN', {
+      code: ACCOUNT_DEACTIVATED_ERROR_CODE,
+      message: 'This account has been deactivated.',
+    });
+}
+
+// deletedAt scope is defence in depth: Better Auth already skips `after` when
+// `before` throws, but a deactivated row must never be stamped regardless.
+export async function recordSignIn(userId: string): Promise<void> {
+  await prisma.user.updateMany({
+    where: { id: userId, deletedAt: null },
+    data: { lastLoginAt: new Date() },
+  });
+}
diff --git a/prisma/migrations/20260924232626_add_user_last_login_at/migration.sql b/prisma/migrations/20260924232626_add_user_last_login_at/migration.sql
new file mode 100644
index 00000000..2667ab27
--- /dev/null
+++ b/prisma/migrations/20260924232626_add_user_last_login_at/migration.sql
@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "User" ADD COLUMN     "lastLoginAt" TIMESTAMP(3);
diff --git a/prisma/schema.prisma b/prisma/schema.prisma
index d8f89a88..ca7462df 100644
--- a/prisma/schema.prisma
+++ b/prisma/schema.prisma
@@ -70,6 +70,7 @@ model User {
   createdAt     DateTime  @default(now())
   updatedAt     DateTime  @updatedAt
   deletedAt     DateTime?
+  lastLoginAt   DateTime?
   createdById   String?
   updatedById   String?
   deletedById   String?
diff --git a/tests/db/last-sign-in.test.ts b/tests/db/last-sign-in.test.ts
new file mode 100644
index 00000000..bdfca5cb
--- /dev/null
+++ b/tests/db/last-sign-in.test.ts
@@ -0,0 +1,84 @@
+import { cleanupFixtures, createTestUser } from '@/tests/helpers/fixtures';
+import { afterAll, describe, expect, it } from 'vitest';
+
+import { getUsersForAdmin } from '@/prisma/data/users';
+
+import {
+  assertSessionUserActive,
+  recordSignIn,
+} from '@/lib/auth/session-hooks';
+import { ACCOUNT_DEACTIVATED_ERROR_CODE } from '@/lib/constants';
+import { prisma } from '@/lib/prisma';
+
+afterAll(async () => {
+  await cleanupFixtures();
+});
+
+describe('recordSignIn', () => {
+  it('stamps a null lastLoginAt', async () => {
+    const user = await createTestUser();
+    expect(user.lastLoginAt).toBeNull();
+
+    await recordSignIn(user.id);
+
+    const stamped = await prisma.user.findUniqueOrThrow({
+      where: { id: user.id },
+    });
+    expect(stamped.lastLoginAt).not.toBeNull();
+  });
+
+  it('overwrites an earlier stamp on a second call', async () => {
+    const user = await createTestUser();
+
+    await recordSignIn(user.id);
+    const first = await prisma.user.findUniqueOrThrow({
+      where: { id: user.id },
+    });
+
+    await recordSignIn(user.id);
+    const second = await prisma.user.findUniqueOrThrow({
+      where: { id: user.id },
+    });
+
+    expect(second.lastLoginAt!.getTime()).toBeGreaterThanOrEqual(
+      first.lastLoginAt!.getTime(),
+    );
+  });
+
+  it('leaves a deactivated user untouched', async () => {
+    const user = await createTestUser({ deletedAt: new Date() });
+
+    await recordSignIn(user.id);
+
+    const unchanged = await prisma.user.findUniqueOrThrow({
+      where: { id: user.id },
+    });
+    expect(unchanged.lastLoginAt).toBeNull();
+  });
+});
+
+describe('assertSessionUserActive', () => {
+  it('rejects a deactivated user with ACCOUNT_DEACTIVATED_ERROR_CODE', async () => {
+    const user = await createTestUser({ deletedAt: new Date() });
+
+    await expect(assertSessionUserActive(user.id)).rejects.toMatchObject({
+      body: { code: ACCOUNT_DEACTIVATED_ERROR_CODE },
+    });
+  });
+
+  it('resolves for an active user', async () => {
+    const user = await createTestUser();
+    await expect(assertSessionUserActive(user.id)).resolves.toBeUndefined();
+  });
+});
+
+describe('getUsersForAdmin', () => {
+  it('includes lastLoginAt', async () => {
+    const user = await createTestUser();
+    await recordSignIn(user.id);
+
+    const list = await getUsersForAdmin();
+    const row = list.find((u) => u.id === user.id);
+    expect(row?.lastLoginAt).not.toBeNull();
+  });
+});

From 9cac4c362afbf53bb42b73cb8948d78063d305e3 Mon Sep 17 00:00:00 2001
From: Ciel Bellerose <kcbellerose@icloud.com>
Date: Thu, 24 Sep 2026 19:30:02 -0400
Subject: [PATCH 31/35] #645 extract DataTable's row comparator into sortRows

Makes the nulls-last sort rule unit-testable independently of the
DataTable component; behavior is unchanged.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 components/ui/data-table.tsx  | 16 +++-----------
 lib/data-table.ts             | 23 ++++++++++++++++++++
 tests/unit/data-table.test.ts | 41 +++++++++++++++++++++++++++++++++++
 3 files changed, 67 insertions(+), 13 deletions(-)

diff --git a/components/ui/data-table.tsx b/components/ui/data-table.tsx
index 495eefae..c5be5666 100644
--- a/components/ui/data-table.tsx
+++ b/components/ui/data-table.tsx
@@ -9,7 +9,7 @@ import {
   type DataTableColumn,
   type SortDirection,
   type SortState,
-  compareValues,
+  sortRows,
 } from '@/lib/data-table';
 import { ACTION_ICONS } from '@/lib/icons';
 import { cn } from '@/lib/utils';
@@ -268,19 +268,9 @@ export function DataTable<T>({
   const sortedRows = useMemo(() => {
     if (controlled || !sort.key) return rows;
     const column = columns.find((c) => c.key === sort.key && c.sortAccessor);
-    if (!column?.sortAccessor) return rows;
+    if (!column) return rows;
 
-    return [...rows].sort((a, b) => {
-      const valA = column.sortAccessor?.(a);
-      const valB = column.sortAccessor?.(b);
-
-      if (valA == null && valB == null) return 0;
-      if (valA == null) return 1;
-      if (valB == null) return -1;
-
-      const cmp = compareValues(valA, valB);
-      return sort.direction === 'desc' ? -cmp : cmp;
-    });
+    return sortRows(rows, column, sort.direction);
   }, [controlled, rows, columns, sort.key, sort.direction]);
 
   function ariaSort(key: string): 'ascending' | 'descending' | 'none' {
diff --git a/lib/data-table.ts b/lib/data-table.ts
index ae1c814e..a62a60fe 100644
--- a/lib/data-table.ts
+++ b/lib/data-table.ts
@@ -64,6 +64,29 @@ export function compareValues(
   return arrA.length - arrB.length;
 }
 
+// Nulls sort last regardless of direction — the null check runs before the
+// direction negation below.
+export function sortRows<T>(
+  rows: T[],
+  column: DataTableColumn<T>,
+  direction: SortDirection,
+): T[] {
+  if (!column.sortAccessor) return rows;
+  const sortAccessor = column.sortAccessor;
+
+  return [...rows].sort((a, b) => {
+    const valA = sortAccessor(a);
+    const valB = sortAccessor(b);
+
+    if (valA == null && valB == null) return 0;
+    if (valA == null) return 1;
+    if (valB == null) return -1;
+
+    const cmp = compareValues(valA, valB);
+    return direction === 'desc' ? -cmp : cmp;
+  });
+}
+
 export interface DataTableFilter {
   key: string;
   value: string;
diff --git a/tests/unit/data-table.test.ts b/tests/unit/data-table.test.ts
index eff010d8..4ea4920d 100644
--- a/tests/unit/data-table.test.ts
+++ b/tests/unit/data-table.test.ts
@@ -4,6 +4,7 @@ import {
   type DataTableColumn,
   compareValues,
   filterRows,
+  sortRows,
 } from '@/lib/data-table';
 
 describe('compareValues', () => {
@@ -91,3 +92,43 @@ describe('filterRows', () => {
     ).toEqual([]);
   });
 });
+
+interface DatedRow {
+  id: string;
+  lastLoginAt: Date | null;
+}
+
+const datedRows: DatedRow[] = [
+  { id: 'null-1', lastLoginAt: null },
+  { id: 'old', lastLoginAt: new Date('2026-01-01T00:00:00Z') },
+  { id: 'new', lastLoginAt: new Date('2026-03-01T00:00:00Z') },
+  { id: 'null-2', lastLoginAt: null },
+];
+
+const lastLoginColumn: DataTableColumn<DatedRow> = {
+  key: 'lastLoginAt',
+  header: 'Last sign-in',
+  cell: (r) => r.lastLoginAt?.toISOString() ?? '',
+  sortAccessor: (r) => r.lastLoginAt,
+};
+
+describe('sortRows', () => {
+  it('orders dated rows oldest-first ascending, with nulls last', () => {
+    const result = sortRows(datedRows, lastLoginColumn, 'asc');
+    expect(result.map((r) => r.id)).toEqual(['old', 'new', 'null-1', 'null-2']);
+  });
+
+  it('orders dated rows newest-first descending, with nulls still last', () => {
+    const result = sortRows(datedRows, lastLoginColumn, 'desc');
+    expect(result.map((r) => r.id)).toEqual(['new', 'old', 'null-1', 'null-2']);
+  });
+
+  it('returns the rows unchanged when the column has no sortAccessor', () => {
+    const unsortable: DataTableColumn<DatedRow> = {
+      key: 'lastLoginAt',
+      header: 'Last sign-in',
+      cell: (r) => r.lastLoginAt?.toISOString() ?? '',
+    };
+    expect(sortRows(datedRows, unsortable, 'asc')).toBe(datedRows);
+  });
+});

From 625073c02225c53b994ee85f234a2834f4042efc Mon Sep 17 00:00:00 2001
From: Ciel Bellerose <kcbellerose@icloud.com>
Date: Thu, 24 Sep 2026 19:30:10 -0400
Subject: [PATCH 32/35] #645 add a Last sign-in column to the users page

Sorts nulls (never-signed-in users) last in both directions; dash cells
carry an sr-only "No sign-in recorded" label, and a footnote explains
what the dash means since nothing is backfilled.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 components/features/users-table.tsx | 31 +++++++++++++++++++++++++++++
 docs/WORKFLOWS.md                   |  4 ++--
 lib/types.ts                        |  1 +
 prisma/data/users.ts                |  1 +
 4 files changed, 35 insertions(+), 2 deletions(-)

diff --git a/components/features/users-table.tsx b/components/features/users-table.tsx
index a0fbd99d..ea6c4a76 100644
--- a/components/features/users-table.tsx
+++ b/components/features/users-table.tsx
@@ -178,6 +178,20 @@ export function UsersTable({ users, currentUserId }: UsersTableProps) {
         sortAccessor: (u) => u.createdAt,
         cell: (u) => <LocalTime date={u.createdAt} precision="date" />,
       },
+      {
+        key: 'lastSignIn',
+        header: 'Last sign-in',
+        sortAccessor: (u) => u.lastLoginAt,
+        cell: (u) =>
+          u.lastLoginAt ? (
+            <LocalTime date={u.lastLoginAt} precision="relative" />
+          ) : (
+            <span className="text-muted-foreground">
+              <span aria-hidden>—</span>
+              <span className="sr-only">No sign-in recorded</span>
+            </span>
+          ),
+      },
       {
         key: 'applications',
         header: 'Applications',
@@ -457,6 +471,19 @@ export function UsersTable({ users, currentUserId }: UsersTableProps) {
                       Joined{' '}
                       <LocalTime date={user.createdAt} precision="date" />
                     </span>
+                    <span className="text-muted-foreground">
+                      {user.lastLoginAt ? (
+                        <>
+                          Last sign-in{' '}
+                          <LocalTime
+                            date={user.lastLoginAt}
+                            precision="relative"
+                          />
+                        </>
+                      ) : (
+                        'No sign-in recorded'
+                      )}
+                    </span>
                     {appCount > 0 ? (
                       <Button
                         variant="link"
@@ -524,6 +551,10 @@ export function UsersTable({ users, currentUserId }: UsersTableProps) {
               );
             }}
           />
+          <p className="text-muted-foreground text-xs">
+            &ldquo;—&rdquo; means no sign-in has been recorded since sign-in
+            tracking began.
+          </p>
         </div>
       </TooltipProvider>
 
diff --git a/docs/WORKFLOWS.md b/docs/WORKFLOWS.md
index 80d3c91a..cfba91d3 100644
--- a/docs/WORKFLOWS.md
+++ b/docs/WORKFLOWS.md
@@ -156,7 +156,7 @@ Anyone not signed in. The only routes they can use are `/positions`, `/positions
   - **Use a different email** returns to the email step and clears the code.
   - Invalid or expired code from the link → falls through to the ordinary OTP step with the email pre-captured and the inline error already set; **Send a new code** and **Use a different email** are both available.
   - Malformed or partial link params (bad email, non-6-digit otp, missing param) → the ordinary email step, with the address prefilled if it was valid.
-- **End state** — a session exists. A user row is created on first sign-in if the email was not already invited ([AD-7](#ad-7-create-a-user)). The user goes to the name form if they have no name, otherwise to the sanitized `redirectTo`.
+- **End state** — a session exists, and `User.lastLoginAt` is stamped (`recordSignIn`, run from the session-create `after` hook — a blocked sign-in never reaches it). A user row is created on first sign-in if the email was not already invited ([AD-7](#ad-7-create-a-user)). The user goes to the name form if they have no name, otherwise to the sanitized `redirectTo`.
 
 ### AN-5 Request a new code
 
@@ -680,7 +680,7 @@ An admin is a **manager on every position**: every [Position manager](#position-
 ### AD-10 Find a user
 
 - **Trigger** — `/users`.
-- **Happy path** — rows default-sort by role: admins, then managers, then everyone else, alphabetical by name (email fallback) within each group. Roles is a sortable column; clicking it restores this order after another sort has replaced it. **Role** (All/Admin/Manager) and **Managed position** filters compose with the existing search box (name, email, or a managed position's title); the Managed position select is omitted entirely when no user manages anything. The count line shows the filtered total plus admin and manager counts — both always render, including zero — and updates live as filters change. Role is badge semantics: a user who is both admin and manager counts toward, and is matched by, both figures, even though they sort into the admin group. A user who signed in but never set a name (blank, not missing) sorts and searches by email, and their row shows the email alone in the name position — no placeholder caption, and never a blank cell. The desktop row shows a manager's first two positions plus a `+N more` badge for the rest; hovering, focusing, or tapping the badge discloses the hidden titles in a tooltip, and its accessible name already carries them for screen readers even with the tooltip closed. The mobile card has the vertical room to skip the truncation and lists every managed position.
+- **Happy path** — rows default-sort by role: admins, then managers, then everyone else, alphabetical by name (email fallback) within each group. Roles is a sortable column; clicking it restores this order after another sort has replaced it. **Role** (All/Admin/Manager) and **Managed position** filters compose with the existing search box (name, email, or a managed position's title); the Managed position select is omitted entirely when no user manages anything. The count line shows the filtered total plus admin and manager counts — both always render, including zero — and updates live as filters change. Role is badge semantics: a user who is both admin and manager counts toward, and is matched by, both figures, even though they sort into the admin group. A user who signed in but never set a name (blank, not missing) sorts and searches by email, and their row shows the email alone in the name position — no placeholder caption, and never a blank cell. The desktop row shows a manager's first two positions plus a `+N more` badge for the rest; hovering, focusing, or tapping the badge discloses the hidden titles in a tooltip, and its accessible name already carries them for screen readers even with the tooltip closed. The mobile card has the vertical room to skip the truncation and lists every managed position. A **Last sign-in** column (relative time, exact datetime on hover) shows `—` (announced as "No sign-in recorded") for a user with no stamped `lastLoginAt` — sorting it puts those `—` rows last in both directions, ahead of a stable `createdAt desc` order among themselves; a muted footnote under the table explains the dash. The mobile card shows the same value or "No sign-in recorded" in its meta row.
 - **Failure / edge**
   - No match → the table's "No users match your filters." row/card; **Clear filters** resets search, role and managed position together.
 - **End state** — read-only; promote/deactivate ([AD-8](#ad-8-grant-or-revoke-admin), [AD-9](#ad-9-deactivate-a-user)) work unchanged from either the desktop row or the mobile card.
diff --git a/lib/types.ts b/lib/types.ts
index 94c2addc..93881dc0 100644
--- a/lib/types.ts
+++ b/lib/types.ts
@@ -439,6 +439,7 @@ export type AdminUserListItem = Prisma.UserGetPayload<{
     email: true;
     isAdmin: true;
     createdAt: true;
+    lastLoginAt: true;
     managedPositions: { select: { id: true; title: true } };
     _count: {
       select: {
diff --git a/prisma/data/users.ts b/prisma/data/users.ts
index 724ba87e..0b2194f5 100644
--- a/prisma/data/users.ts
+++ b/prisma/data/users.ts
@@ -14,6 +14,7 @@ export async function getUsersForAdmin(): Promise<AdminUserListItem[]> {
       email: true,
       isAdmin: true,
       createdAt: true,
+      lastLoginAt: true,
       managedPositions: {
         where: { deletedAt: null },
         select: { id: true, title: true },

From ece313a2438132b6984b32a463a5c73fdd093e6b Mon Sep 17 00:00:00 2001
From: Ciel Bellerose <kcbellerose@icloud.com>
Date: Thu, 24 Sep 2026 19:43:34 -0400
Subject: [PATCH 33/35] #775 address review feedback

Deletion no longer erases a position's earlier activity history: opened,
closed and deadline-close rows now survive deletion, rendered unlinked.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 docs/WORKFLOWS.md              |  4 +--
 lib/auth/scopes.ts             | 10 ++++++
 lib/constants.ts               |  4 +++
 lib/types.ts                   | 10 +++---
 prisma/data/activity.ts        | 16 +++++++---
 prisma/data/positions.ts       | 25 +++++++++------
 tests/db/authorization.test.ts | 56 ++++++++++++++++++++++++++++++++--
 7 files changed, 103 insertions(+), 22 deletions(-)

diff --git a/docs/WORKFLOWS.md b/docs/WORKFLOWS.md
index 779a4522..fa2a9dd7 100644
--- a/docs/WORKFLOWS.md
+++ b/docs/WORKFLOWS.md
@@ -96,7 +96,7 @@ Three applicant-facing email _events_, over two rendered templates, all through
 
 A `Sheet` reachable from every authenticated page, not just the dashboard — top-right of the sidebar's `h-14` header bar on desktop, and immediately left of the hamburger menu on mobile, so the control lands in the same visual position at both breakpoints. Hidden entirely for anonymous visitors. Opens from the right (`side="right"`), so it never reads as the same surface as `MobileNav`'s `side="left"` menu drawer.
 
-- **Composition** — everyone always gets **their own** non-draft applications on published positions, with public status only ([XC-8](#xc-8-applicant-facing-status-grouping)) — this covers a manager or admin who has also applied. Managers and admins additionally get a reviewer group: managed positions only for a manager, every published position for an admin, scoped the same way as [PM-8](#pm-8-work-the-application-queue)'s queue (`buildApplicationScopeWhere`). A manager whose only position was just deleted still counts as having a reviewer group for this — `isManager` alone would say otherwise, since it only counts non-deleted positions — so `getActivityGroups` also unlocks it from a non-empty deletion row. The reviewer group also carries position status rows for positions in that same scope: "\<title\> was opened" / "\<title\> was reopened" / "\<title\> was closed", sourced from `PositionStatusEvent` rows with `to: 'open'` or `to: 'closed'` (`getRecentPositionStatusEvents`), plus a derived "\<title\> closed" row for an `open` position whose `closesAt` has passed with no status change — nothing runs on a schedule to write an event for that, so it's read straight off `closesAt` within `RECENTLY_CLOSED_WINDOW_DAYS` (`getRecentPositionDeadlineCloses`); a manually-closed position never also gets this derived row, since its stored status is no longer `open`. A position deleted while `open` or `closed` (not `draft`) also gets a row, "\<title\> was deleted", read straight off `deletedAt` (`getRecentPositionDeletions`, `buildDeletedPositionWhere`) — the only reviewer-group row not linked, since the position page no longer exists; a deleted position's earlier opened/closed/deadline-close rows drop out, because those queries already require `deletedAt: null`. Every other row links to `/positions/[id]`; unlike applications, none of these position rows get a **self-filter** — the admin who opened, closed or deleted a position still sees it under "All positions". Both groups render when either has items.
+- **Composition** — everyone always gets **their own** non-draft applications on published positions, with public status only ([XC-8](#xc-8-applicant-facing-status-grouping)) — this covers a manager or admin who has also applied. Managers and admins additionally get a reviewer group: managed positions only for a manager, every published position for an admin, scoped the same way as [PM-8](#pm-8-work-the-application-queue)'s queue (`buildApplicationScopeWhere`). A manager whose only position was just deleted still counts as having a reviewer group for this — `isManager` alone would say otherwise, since it only counts non-deleted positions — so `getActivityGroups` also unlocks it from a non-empty deletion row. The reviewer group also carries position status rows for positions in that same scope: "\<title\> was opened" / "\<title\> was reopened" / "\<title\> was closed", sourced from `PositionStatusEvent` rows with `to: 'open'` or `to: 'closed'` (`getRecentPositionStatusEvents`), plus a derived "\<title\> closed" row for an `open` position whose `closesAt` has passed with no status change — nothing runs on a schedule to write an event for that, so it's read straight off `closesAt` within `RECENTLY_CLOSED_WINDOW_DAYS` (`getRecentPositionDeadlineCloses`); a manually-closed position never also gets this derived row, since its stored status is no longer `open`. A position deleted while `open` or `closed` (not `draft`) also gets a row, "\<title\> was deleted", read straight off `deletedAt` (`getRecentPositionDeletions`, `buildDeletedPositionWhere`). Once a row has appeared it survives the position's own later deletion: the opened/closed/deadline-close queries scope by `buildPositionHistoryWhere`, which — unlike `buildReviewablePositionWhere` — never excludes `deletedAt`, so a deleted position's earlier rows keep showing, just unlinked (a deadline that only lapses after deletion still produces nothing). The "was deleted" row and every surviving deleted-position row render **unlinked**, since the position page no longer exists; every other row links to `/positions/[id]`. Unlike applications, none of these position rows get a **self-filter** — the admin who opened, closed or deleted a position still sees it under "All positions". Both groups render when either has items.
 - **Self-filter** — a row in the reviewer group for the viewer's own **application** is dropped; it already appears in "Your applications", and without the filter a manager or admin who applied to a position they review would see their own application twice. Position status rows (opens, closes and deletions) are never self-filtered.
 - **Newest 10, merged** — "Your applications" is capped at 10, newest `submittedAt` first. The reviewer group merges applications and position status rows by timestamp (a deadline close's timestamp is its `closesAt`; a deletion's is its `deletedAt`) and keeps the newest 10 **across all kinds** — an active feed can show fewer than 10 applications to make room for a status row, or vice versa. The application self-filter runs before the merge, so the reviewer group can show fewer than 10 when some of the newest application rows are the viewer's own.
 - **Group headings** — only for a viewer with a reviewer group at all. "Your applications" first, then "Positions you manage" (manager) or "All positions" (admin); a group with no items is omitted. A plain applicant (no reviewer group) sees one flat list with no heading at all.
@@ -612,7 +612,7 @@ An admin is a **manager on every position**: every [Position manager](#position-
 ### AD-3 Delete a position
 
 - **Trigger** — the Delete Position card at the bottom of `/manage/positions/[id]/edit`, rendered only for admins.
-- **Happy path** — the card states "Deleting hides this position everywhere — the positions list, search results and any direct link. This can't be undone from the app." The confirmation names the position and, when relevant, adds "N unsubmitted draft applications will disappear too." `deletePosition` soft-deletes with the blocking condition folded into the `where`, so the check and the write are one atomic statement. Toast **"Position deleted"**. Deleting a position that was `open` or `closed` (not `draft`) is the only signal back to its managers — an unlinked "\<title\> was deleted" activity-panel item, derived from `deletedAt` ([XC-10](#xc-10-activity-panel)); a deleted draft produces no row.
+- **Happy path** — the card states "Deleting hides this position everywhere — the positions list, search results and any direct link. This can't be undone from the app." The confirmation names the position and, when relevant, adds "N unsubmitted draft applications will disappear too." `deletePosition` soft-deletes with the blocking condition folded into the `where`, so the check and the write are one atomic statement. Toast **"Position deleted"**. Deleting a position that was `open` or `closed` (not `draft`) signals its managers with an unlinked "\<title\> was deleted" activity-panel item, derived from `deletedAt`; its earlier opened/closed/deadline-close rows persist too, also unlinked ([XC-10](#xc-10-activity-panel)); a deleted draft produces no row.
 - **Failure / edge**
   - Any non-draft application exists → the button is disabled, and a stale tab that posts anyway gets `POSITION_DELETE_BLOCKED_ERROR`: **"This position has applications, so it can't be deleted. Close it instead."**
   - Already deleted → **"This position no longer exists."**
diff --git a/lib/auth/scopes.ts b/lib/auth/scopes.ts
index 981f8f29..93a69460 100644
--- a/lib/auth/scopes.ts
+++ b/lib/auth/scopes.ts
@@ -26,6 +26,16 @@ export function buildDeletedPositionWhere(
   return user.isAdmin ? base : { ...base, managers: { some: { id: user.id } } };
 }
 
+// Same admin/manager split, but omits buildReviewablePositionWhere's deletedAt:
+// null — for activity rows a position already produced, which must survive
+// its own later deletion.
+export function buildPositionHistoryWhere(
+  user: Reviewer,
+): Prisma.PositionWhereInput {
+  const base = { status: { not: 'draft' } } as const;
+  return user.isAdmin ? base : { ...base, managers: { some: { id: user.id } } };
+}
+
 // `status` omitted so a caller's own filter can't overwrite the position scoping.
 export function buildApplicationScopeWhere(
   user: Reviewer,
diff --git a/lib/constants.ts b/lib/constants.ts
index 7f57703b..053811e7 100644
--- a/lib/constants.ts
+++ b/lib/constants.ts
@@ -1008,6 +1008,10 @@ export const POSITION_STATUS_BADGE_VARIANT: Record<
   BadgeVariant
 > = { draft: 'secondary', open: 'default', closed: 'outline' };
 
+// No 'deleted' member on PositionStatus, so the deletion activity row's badge
+// isn't part of the map above.
+export const POSITION_DELETED_BADGE_VARIANT: BadgeVariant = 'destructive';
+
 // Position-scoped surfaces (draft still shows its applications); PUBLISHED is for cross-position ones.
 export const VISIBLE_POSITION_WHERE = {
   deletedAt: null,
diff --git a/lib/types.ts b/lib/types.ts
index 09ea9a7d..e247a3ef 100644
--- a/lib/types.ts
+++ b/lib/types.ts
@@ -413,7 +413,7 @@ export type QuestionFileDownload = {
 };
 
 // sentence is pre-rendered safe copy; statusVariant drives the dot color.
-// href is set only for linkable rows (position opens/closes).
+// href is unset for a deleted position's rows — the page no longer exists.
 export type ActivityItem = {
   id: string;
   statusVariant: BadgeVariant;
@@ -435,20 +435,22 @@ export type ActivityGroups = {
 
 // Matches getRecentPositionStatusEvents's select in prisma/data/positions.ts.
 // No actor identity selected — changedBy never reaches the activity panel.
+// position.deletedAt drives whether the row renders unlinked.
 export type PositionStatusActivity = Prisma.PositionStatusEventGetPayload<{
   select: {
     id: true;
     from: true;
     to: true;
     createdAt: true;
-    position: { select: { id: true; title: true } };
+    position: { select: { id: true; title: true; deletedAt: true } };
   };
 }>;
 
 // Matches getRecentPositionDeadlineCloses's select — no event backs this row,
-// so closesAt itself (guaranteed non-null by that query's where) is the timestamp.
+// so closesAt itself (guaranteed non-null by that query's where) is the
+// timestamp; deletedAt drives whether it renders unlinked.
 export type PositionDeadlineCloseActivity = Prisma.PositionGetPayload<{
-  select: { id: true; title: true; closesAt: true };
+  select: { id: true; title: true; closesAt: true; deletedAt: true };
 }>;
 
 // Matches getRecentPositionDeletions's select — no event backs this row either,
diff --git a/prisma/data/activity.ts b/prisma/data/activity.ts
index 950f822e..b0770e7c 100644
--- a/prisma/data/activity.ts
+++ b/prisma/data/activity.ts
@@ -19,6 +19,7 @@ import {
   POSITION_ACTIVITY_SENTENCE,
   POSITION_CLOSED_BY_DATE_SENTENCE,
   POSITION_CLOSED_SENTENCE,
+  POSITION_DELETED_BADGE_VARIANT,
   POSITION_DELETED_SENTENCE,
   POSITION_STATUS_BADGE_VARIANT,
 } from '@/lib/constants';
@@ -96,7 +97,10 @@ export const getActivityGroups = cache(async function getActivityGroups(
       statusVariant: POSITION_STATUS_BADGE_VARIANT.open,
       sentence: POSITION_ACTIVITY_SENTENCE[event.from](event.position.title),
       timestamp: event.createdAt,
-      href: `/positions/${event.position.id}`,
+      href:
+        event.position.deletedAt === null
+          ? `/positions/${event.position.id}`
+          : undefined,
     }));
 
   const closedItems: ActivityItem[] = statusEvents
@@ -106,7 +110,10 @@ export const getActivityGroups = cache(async function getActivityGroups(
       statusVariant: POSITION_STATUS_BADGE_VARIANT.closed,
       sentence: POSITION_CLOSED_SENTENCE(event.position.title),
       timestamp: event.createdAt,
-      href: `/positions/${event.position.id}`,
+      href:
+        event.position.deletedAt === null
+          ? `/positions/${event.position.id}`
+          : undefined,
     }));
 
   // closesAt is guaranteed non-null by the query's where — narrow, not cast.
@@ -120,7 +127,8 @@ export const getActivityGroups = cache(async function getActivityGroups(
       statusVariant: POSITION_STATUS_BADGE_VARIANT.closed,
       sentence: POSITION_CLOSED_BY_DATE_SENTENCE(position.title),
       timestamp: position.closesAt,
-      href: `/positions/${position.id}`,
+      href:
+        position.deletedAt === null ? `/positions/${position.id}` : undefined,
     }));
 
   // deletedAt is guaranteed non-null by the query's where — narrow, not cast.
@@ -132,7 +140,7 @@ export const getActivityGroups = cache(async function getActivityGroups(
     )
     .map((position) => ({
       id: `deletion-${position.id}`,
-      statusVariant: 'destructive',
+      statusVariant: POSITION_DELETED_BADGE_VARIANT,
       sentence: POSITION_DELETED_SENTENCE(position.title),
       timestamp: position.deletedAt,
     }));
diff --git a/prisma/data/positions.ts b/prisma/data/positions.ts
index a3448414..4f9965f5 100644
--- a/prisma/data/positions.ts
+++ b/prisma/data/positions.ts
@@ -4,7 +4,7 @@ import { cache } from 'react';
 
 import {
   buildDeletedPositionWhere,
-  buildReviewablePositionWhere,
+  buildPositionHistoryWhere,
 } from '@/lib/auth/scopes';
 import {
   MANAGED_POSITIONS_WINDOW_DAYS,
@@ -387,7 +387,8 @@ export async function getPositionDeletionSummary(
   return { submittedCount, draftCount };
 }
 
-// Scoped identically to getRecentApplications so drift can't desync the two feeds.
+// buildPositionHistoryWhere, not buildReviewablePositionWhere, so opened/closed
+// rows outlive the position's own later deletion.
 export async function getRecentPositionStatusEvents(
   reviewer: Reviewer,
   take: number,
@@ -395,21 +396,22 @@ export async function getRecentPositionStatusEvents(
   return prisma.positionStatusEvent.findMany({
     where: {
       to: { in: ['open', 'closed'] },
-      position: buildReviewablePositionWhere(reviewer),
+      position: buildPositionHistoryWhere(reviewer),
     },
     select: {
       id: true,
       from: true,
       to: true,
       createdAt: true,
-      position: { select: { id: true, title: true } },
+      position: { select: { id: true, title: true, deletedAt: true } },
     },
     orderBy: [{ createdAt: 'desc' }, { id: 'desc' }],
     take,
   });
 }
 
-// No event backs a deadline lapse, so this derives from closesAt; status: 'open' excludes a manually-closed position from double-reporting.
+// No event backs a deadline lapse, so this derives from closesAt; status: 'open'
+// excludes a manually-closed position from double-reporting.
 export async function getRecentPositionDeadlineCloses(
   reviewer: Reviewer,
   take: number,
@@ -418,16 +420,21 @@ export async function getRecentPositionDeadlineCloses(
   const cutoff = new Date(now);
   cutoff.setDate(cutoff.getDate() - RECENTLY_CLOSED_WINDOW_DAYS);
 
-  return prisma.position.findMany({
+  const positions = await prisma.position.findMany({
     where: {
-      ...buildReviewablePositionWhere(reviewer),
+      ...buildPositionHistoryWhere(reviewer),
       status: 'open',
       closesAt: { gte: cutoff, lte: now },
     },
-    select: { id: true, title: true, closesAt: true },
+    select: { id: true, title: true, closesAt: true, deletedAt: true },
     orderBy: [{ closesAt: 'desc' }, { id: 'desc' }],
-    take,
   });
+
+  // Excludes a deadline lapsing only after deletion — Prisma can't compare two
+  // columns of one row in a where, so this runs post-fetch.
+  return positions
+    .filter((p) => p.deletedAt === null || p.closesAt! <= p.deletedAt)
+    .slice(0, take);
 }
 
 // buildDeletedPositionWhere, not buildReviewablePositionWhere, since these
diff --git a/tests/db/authorization.test.ts b/tests/db/authorization.test.ts
index 8f1fb8d4..75b5b97c 100644
--- a/tests/db/authorization.test.ts
+++ b/tests/db/authorization.test.ts
@@ -1181,6 +1181,7 @@ describe('getActivityGroups composition and scoping', () => {
     expect(result).toBeUndefined();
 
     const groups = await getActivityGroups(manager.id, false);
+    expect(groups.scope).toBe('managed');
     const item = groups.reviewed.find((i) =>
       i.sentence.includes(position.title),
     );
@@ -1234,7 +1235,7 @@ describe('getActivityGroups composition and scoping', () => {
     );
   });
 
-  it('deletion: an admin sees it under "all", and the earlier opening drops out', async () => {
+  it('deletion: an admin sees it under "all", and the earlier opened/closed rows persist unlinked', async () => {
     const manager = await createTestUser();
     const position = await createTestPosition(admin, {
       managers: [manager],
@@ -1243,13 +1244,62 @@ describe('getActivityGroups composition and scoping', () => {
 
     actAs(admin);
     await updatePositionStatus({ id: position.id, status: 'open' });
+    await updatePositionStatus({ id: position.id, status: 'closed' });
     await deletePosition({ id: position.id });
 
     const groups = await getActivityGroups(admin.id, true);
     expect(groups.scope).toBe('all');
+    const opened = groups.reviewed.find(
+      (i) => i.sentence === `${position.title} was opened`,
+    );
+    const closed = groups.reviewed.find(
+      (i) => i.sentence === `${position.title} was closed`,
+    );
+    const deleted = groups.reviewed.find(
+      (i) => i.sentence === `${position.title} was deleted`,
+    );
+    expect(opened).toBeDefined();
+    expect(opened?.href).toBeUndefined();
+    expect(closed).toBeDefined();
+    expect(closed?.href).toBeUndefined();
+    expect(deleted).toBeDefined();
+  });
+
+  it('deletion: a deadline-close row already produced before deletion persists unlinked', async () => {
+    const manager = await createTestUser();
+    const past = new Date(Date.now() - 60 * 60 * 1000);
+    const position = await createTestPosition(admin, {
+      managers: [manager],
+      status: 'open',
+      closesAt: past,
+    });
+
+    actAs(admin);
+    await deletePosition({ id: position.id });
+
+    const groups = await getActivityGroups(manager.id, false);
+    const item = groups.reviewed.find(
+      (i) => i.sentence === `${position.title} closed`,
+    );
+    expect(item).toBeDefined();
+    expect(item?.href).toBeUndefined();
+  });
+
+  it('deletion: a deadline lapsing only after deletion produces no row', async () => {
+    const manager = await createTestUser();
+    const deletedAt = new Date(Date.now() - 2 * 60 * 60 * 1000);
+    const closesAt = new Date(Date.now() - 60 * 60 * 1000);
+    const position = await createTestPosition(admin, {
+      managers: [manager],
+      status: 'open',
+      closesAt,
+      deletedAt,
+      deletedById: admin.id,
+    });
+
+    const groups = await getActivityGroups(manager.id, false);
     const sentences = groups.reviewed.map((i) => i.sentence);
-    expect(sentences).toContain(`${position.title} was deleted`);
-    expect(sentences).not.toContain(`${position.title} was opened`);
+    expect(sentences).not.toContain(`${position.title} closed`);
   });
 
   it('merges openings with applications by time and caps the combined feed at 10', async () => {

From 8d45b25d6133e88dd72d7a70205abb8e83ff102f Mon Sep 17 00:00:00 2001
From: Ciel Bellerose <kcbellerose@icloud.com>
Date: Thu, 24 Sep 2026 19:49:15 -0400
Subject: [PATCH 34/35] #645 address review feedback
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Remove the permanent footnote under the users table per operator
request; the "—" cell and its screen-reader text still explain the
missing sign-in.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 components/features/users-table.tsx | 4 ----
 docs/WORKFLOWS.md                   | 2 +-
 2 files changed, 1 insertion(+), 5 deletions(-)

diff --git a/components/features/users-table.tsx b/components/features/users-table.tsx
index ea6c4a76..3264621b 100644
--- a/components/features/users-table.tsx
+++ b/components/features/users-table.tsx
@@ -551,10 +551,6 @@ export function UsersTable({ users, currentUserId }: UsersTableProps) {
               );
             }}
           />
-          <p className="text-muted-foreground text-xs">
-            &ldquo;—&rdquo; means no sign-in has been recorded since sign-in
-            tracking began.
-          </p>
         </div>
       </TooltipProvider>
 
diff --git a/docs/WORKFLOWS.md b/docs/WORKFLOWS.md
index cfba91d3..980630b1 100644
--- a/docs/WORKFLOWS.md
+++ b/docs/WORKFLOWS.md
@@ -680,7 +680,7 @@ An admin is a **manager on every position**: every [Position manager](#position-
 ### AD-10 Find a user
 
 - **Trigger** — `/users`.
-- **Happy path** — rows default-sort by role: admins, then managers, then everyone else, alphabetical by name (email fallback) within each group. Roles is a sortable column; clicking it restores this order after another sort has replaced it. **Role** (All/Admin/Manager) and **Managed position** filters compose with the existing search box (name, email, or a managed position's title); the Managed position select is omitted entirely when no user manages anything. The count line shows the filtered total plus admin and manager counts — both always render, including zero — and updates live as filters change. Role is badge semantics: a user who is both admin and manager counts toward, and is matched by, both figures, even though they sort into the admin group. A user who signed in but never set a name (blank, not missing) sorts and searches by email, and their row shows the email alone in the name position — no placeholder caption, and never a blank cell. The desktop row shows a manager's first two positions plus a `+N more` badge for the rest; hovering, focusing, or tapping the badge discloses the hidden titles in a tooltip, and its accessible name already carries them for screen readers even with the tooltip closed. The mobile card has the vertical room to skip the truncation and lists every managed position. A **Last sign-in** column (relative time, exact datetime on hover) shows `—` (announced as "No sign-in recorded") for a user with no stamped `lastLoginAt` — sorting it puts those `—` rows last in both directions, ahead of a stable `createdAt desc` order among themselves; a muted footnote under the table explains the dash. The mobile card shows the same value or "No sign-in recorded" in its meta row.
+- **Happy path** — rows default-sort by role: admins, then managers, then everyone else, alphabetical by name (email fallback) within each group. Roles is a sortable column; clicking it restores this order after another sort has replaced it. **Role** (All/Admin/Manager) and **Managed position** filters compose with the existing search box (name, email, or a managed position's title); the Managed position select is omitted entirely when no user manages anything. The count line shows the filtered total plus admin and manager counts — both always render, including zero — and updates live as filters change. Role is badge semantics: a user who is both admin and manager counts toward, and is matched by, both figures, even though they sort into the admin group. A user who signed in but never set a name (blank, not missing) sorts and searches by email, and their row shows the email alone in the name position — no placeholder caption, and never a blank cell. The desktop row shows a manager's first two positions plus a `+N more` badge for the rest; hovering, focusing, or tapping the badge discloses the hidden titles in a tooltip, and its accessible name already carries them for screen readers even with the tooltip closed. The mobile card has the vertical room to skip the truncation and lists every managed position. A **Last sign-in** column (relative time, exact datetime on hover) shows `—` (announced as "No sign-in recorded") for a user with no stamped `lastLoginAt` — sorting it puts those `—` rows last in both directions, ahead of a stable `createdAt desc` order among themselves. The mobile card shows the same value or "No sign-in recorded" in its meta row.
 - **Failure / edge**
   - No match → the table's "No users match your filters." row/card; **Clear filters** resets search, role and managed position together.
 - **End state** — read-only; promote/deactivate ([AD-8](#ad-8-grant-or-revoke-admin), [AD-9](#ad-9-deactivate-a-user)) work unchanged from either the desktop row or the mobile card.

From ffce431809182037e9904d1cf3d0617b38176152 Mon Sep 17 00:00:00 2001
From: b-at-neu <winkler.b@northeastern.edu>
Date: Fri, 25 Sep 2026 09:56:41 -0400
Subject: [PATCH 35/35] bump version to v1.14.0

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 package-lock.json | 4 ++--
 package.json      | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 10e9c30b..a6d2683b 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "aplio",
-  "version": "1.13.1",
+  "version": "1.14.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "aplio",
-      "version": "1.13.1",
+      "version": "1.14.0",
       "dependencies": {
         "@better-auth/prisma-adapter": "^1.6.29",
         "@dnd-kit/core": "^6.3.1",
diff --git a/package.json b/package.json
index d38da845..482c1a6c 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "aplio",
-  "version": "1.13.1",
+  "version": "1.14.0",
   "private": true,
   "engines": {
     "node": "24.x",