@@ -0,0 +1,37 @@
+name: Sponsorship — Hourly DRI Sync
+
+# Keeps PERBot's DRI ledger (`DRI assigned` on each Pipeline deal) in step with the DRI
+# people property: stamps newly-added DRIs with the time they were noticed, drops removed
+# ones, backfills pre-ledger deals with their creation time. This is what lets the weekly
+# quota audit count re-assignments onto older deals. Idempotent — only changed deals are
+# written — so late/double cron fires are harmless.
+on:
+  schedule:
+    - cron: '30 * * * *' # hourly, offset from the win-post job
+  workflow_dispatch:
+
+jobs:
+  dri-sync:
+    runs-on: ubuntu-latest
+    concurrency:
+      group: sponsor-dri-sync
+      cancel-in-progress: false
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: 'npm'
+          cache-dependency-path: PERBot/package-lock.json
+
+      - name: Install dependencies
+        working-directory: PERBot
+        run: npm ci
+
+      - name: Sync the DRI ledger
+        working-directory: PERBot
+        run: npm run job:sponsor-dri-sync
+        env:
+          SLACK_BOT_TOKEN: ${{ secrets.SLACK_BOT_TOKEN }}
+          NOTION_API_KEY: ${{ secrets.NOTION_API_KEY }}
@@ -18,6 +18,7 @@
     "job:sponsor-reply": "tsx src/sponsorship/jobs/replyDm.ts",
     "job:sponsor-digest": "tsx src/sponsorship/jobs/weeklyDigest.ts",
     "job:sponsor-quota": "tsx src/sponsorship/jobs/quotaAudit.ts",
+    "job:sponsor-dri-sync": "tsx src/sponsorship/jobs/driSync.ts",
     "check": "tsc --noEmit"
   },
   "dependencies": {
 
@@ -0,0 +1,56 @@
+import { logger } from '../../utils/logger.js';
+import { SponsorNotion } from '../notion.js';
+import { PipelineRow } from '../types.js';
+
+/**
+ * Hourly DRI sync: Notion doesn't record WHEN a person was added to a people property,
+ * so PERBot keeps its own ledger on each Pipeline deal (`DRI assigned`: one
+ * "<user id> <ISO>" line per current DRI). Each run diffs every deal's DRI set against
+ * its ledger — new DRIs are stamped, removed DRIs are dropped, deals whose ledger is
+ * empty are backfilled with the deal's creation time (the best evidence for assignments
+ * that predate the ledger). The quota audit + `/sponsor quota` count by these stamps, so
+ * a re-assignment onto an older deal counts in the week it happened (Arjun's rule,
+ * 2026-09-11). Granularity is the sync cadence: an assign→unassign inside one hour is
+ * invisible, which is fine.
+ *
+ * Idempotent by construction: only deals whose ledger would change are written.
+ */
+
+/** The ledger a deal should have now, or null if it's already correct. */
+export function reconcileLedger(deal: PipelineRow, nowIso: string): Record<string, string> | null {
+  const current = new Set(deal.driUserIds.map((id) => id.toLowerCase()));
+  const next: Record<string, string> = {};
+  const ledgerEmpty = Object.keys(deal.driAssignedAt).length === 0;
+  for (const id of current) {
+    // First-ever stamp on a deal → the deal's creation time (pre-ledger assignments);
+    // later additions → now.
+    next[id] = deal.driAssignedAt[id] ?? (ledgerEmpty && deal.createdTime ? deal.createdTime : nowIso);
+  }
+  const before = Object.entries(deal.driAssignedAt).sort().join('|');
+  const after = Object.entries(next).sort().join('|');
+  return before === after ? null : next;
+}
+
+export async function syncDriLedger(notion: SponsorNotion = new SponsorNotion()): Promise<{ scanned: number; updated: number }> {
+  const deals = await notion.queryAllDeals();
+  const nowIso = new Date().toISOString();
+  let updated = 0;
+  for (const deal of deals) {
+    const next = reconcileLedger(deal, nowIso);
+    if (!next) continue;
+    await notion.writeDriLedger(deal.id, next);
+    updated += 1;
+    logger.info(`DRI sync: ${deal.company || deal.id} → ${Object.keys(next).length} DRI(s) stamped.`);
+  }
+  logger.info(`DRI sync: scanned ${deals.length} deals, updated ${updated}.`);
+  return { scanned: deals.length, updated };
+}
+
+// Entrypoint when run directly (GitHub Actions).
+const isMain = process.argv[1] && import.meta.url === `file://${process.argv[1]}`;
+if (isMain) {
+  syncDriLedger().catch((err) => {
+    logger.error('DRI sync job failed.', err);
+    process.exitCode = 1;
+  });
+}
@@ -5,16 +5,17 @@ import { etWallTimeToUtc, isoAddDays, todayIsoET } from '../dates.js';
 import { fetchSlackDirectory, Indexed, notionUserToSlackId } from '../identity.js';
 import { SponsorNotion } from '../notion.js';
 import { NotionUser, PipelineRow, QuotaAuditResult, QuotaRosterMember } from '../types.js';
+import { syncDriLedger } from './driSync.js';
 import { alreadyPosted, makeSlackClient, metadataFor, resolveChannelId, WinMeta } from './shared.js';
 
 /**
  * Saturday 10 AM ET weekly quota audit: every active member of the 👥 Ops Quota Roster
  * (a Notion DB ops leads maintain — no deploy to change who's on the hook) must have
  * been assigned as DRI on `config.sponsorship.weeklyQuota` Pipeline deals in the past
- * week. "Assigned this week" = the deal's Notion page was created inside the window
- * [last Sat 10:00 ET, this Sat 10:00 ET) with the member on its DRI. Every `/sponsor
- * add … @person`, `/sponsor claim`, and hand-made Pipeline row counts; co-owned deals
- * credit each DRI in full (same rule as the leaderboard).
+ * week. "Assigned this week" = the member's DRI stamp on the deal (PERBot's `DRI assigned`
+ * ledger, kept by jobs/driSync.ts; falls back to the deal's creation time) falls inside the
+ * window [last Sat 10:00 ET, this Sat 10:00 ET). So new deals AND re-assignments onto
+ * older deals count; co-owned deals credit each DRI in full (same rule as the leaderboard).
  *
  * Output: (1) one row per member per week upserted into 📋 Weekly Quota Audit — the
  * durable record of who met quota and who didn't; (2) ONE channel post (#perbot_spam)
@@ -60,25 +61,45 @@ export function auditWindow(weekEndIso: string = todayIsoET()): AuditWindow {
 }
 
 /**
- * Pure audit: for each roster member, the deals created inside the window that list
- * them as DRI, and whether that count reaches the quota. `deals` may include rows
- * outside the window (the Notion query is only lower-bounded) — filtered here.
+ * The window currently in progress — ends at 10:00 ET on the next Saturday (today, if it's
+ * Saturday before 10am; next week's if the 10am audit has already run). Powers the
+ * `/sponsor quota` mid-week self-check so people see the same window Saturday will judge.
+ */
+export function currentAuditWindow(now: Date = new Date()): AuditWindow {
+  const todayIso = now.toLocaleDateString('en-CA', { timeZone: 'America/New_York' });
+  const weekday = now.toLocaleDateString('en-US', { weekday: 'short', timeZone: 'America/New_York' });
+  const hour = Number(now.toLocaleString('en-US', { hour: '2-digit', hour12: false, timeZone: 'America/New_York' }));
+  const dow = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'].indexOf(weekday);
+  let daysToSaturday = (6 - dow + 7) % 7;
+  if (daysToSaturday === 0 && hour >= AUDIT_HOUR_ET) daysToSaturday = 7;
+  return auditWindow(isoAddDays(todayIso, daysToSaturday));
+}
+
+/** When `userId` was assigned to `deal`: the ledger stamp, else the deal's creation time. */
+export function assignedAtIso(deal: PipelineRow, userId: string): string {
+  return deal.driAssignedAt[userId.toLowerCase()] ?? deal.createdTime;
+}
+
+/**
+ * Pure audit: for each roster member, the deals they were assigned to inside the window
+ * (current DRI + assignment stamp in range), and whether that count reaches the quota.
+ * `deals` may include rows outside the window (the Notion query is only lower-bounded).
  */
 export function computeQuotaResults(
   members: QuotaRosterMember[],
   deals: PipelineRow[],
   window: AuditWindow,
   quota: number
 ): QuotaAuditResult[] {
-  const inWindow = deals.filter((d) => {
-    if (!d.createdTime) return false;
-    const t = new Date(d.createdTime).getTime();
+  const inWindow = (iso: string) => {
+    if (!iso) return false;
+    const t = new Date(iso).getTime();
     return t >= window.start.getTime() && t < window.end.getTime();
-  });
+  };
   return members.map((member) => {
-    const mine = inWindow
-      .filter((d) => d.driUserIds.includes(member.notionUserId))
-      .sort((a, b) => a.createdTime.localeCompare(b.createdTime));
+    const mine = deals
+      .filter((d) => d.driUserIds.includes(member.notionUserId) && inWindow(assignedAtIso(d, member.notionUserId)))
+      .sort((a, b) => assignedAtIso(a, member.notionUserId).localeCompare(assignedAtIso(b, member.notionUserId)));
     return {
       member,
       weekStartIso: window.weekStartIso,
@@ -90,7 +111,7 @@ export function computeQuotaResults(
   });
 }
 
-function fmtDate(iso: string): string {
+export function fmtDate(iso: string): string {
   return new Date(`${iso}T12:00:00Z`).toLocaleDateString('en-US', { month: 'short', day: 'numeric', timeZone: 'UTC' });
 }
 
@@ -111,7 +132,7 @@ export function buildQuotaPost(
 
   const lines = [
     `:clipboard: *Weekly sponsorship quota audit* — ${fmtDate(window.weekStartIso)} → ${fmtDate(window.weekEndIso)}`,
-    `_Quota: ${quota} new sponsor assignment${plural} per ops member (a Pipeline deal opened this week with you as DRI)._`,
+    `_Quota: ${quota} new sponsor assignment${plural} per ops member (Pipeline deals you were made DRI on this week — new or re-assigned)._`,
   ];
   if (met.length > 0) {
     lines.push(`:white_check_mark: *Met (${met.length}/${total}):* ${met.map((r) => `${r.member.name} (${r.deals.length})`).join(' · ')}`);
@@ -128,6 +149,45 @@ export function buildQuotaPost(
   return lines.join('\n');
 }
 
+/**
+ * Ephemeral `/sponsor quota` text: the caller's own standing first (if they're on the
+ * roster), then the whole team's, so anyone can see where things stand before Saturday.
+ */
+export function formatQuotaStanding(
+  results: QuotaAuditResult[],
+  window: AuditWindow,
+  quota: number,
+  callerNotionId: string | null
+): string {
+  const header = `*Sponsor quota — week of ${fmtDate(window.weekStartIso)} → ${fmtDate(window.weekEndIso)}* (audited Sat 10am ET, posted to #${config.sponsorship.quotaChannel})`;
+  const lines = [header];
+
+  const mine = callerNotionId ? results.find((r) => r.member.notionUserId === callerNotionId) : undefined;
+  if (mine) {
+    const deals = mine.deals.length ? ` — ${mine.deals.map((d) => `<${d.url}|${d.company || 'Untitled'}>`).join(', ')}` : '';
+    const remaining = quota - mine.deals.length;
+    lines.push(
+      mine.met
+        ? `:white_check_mark: *You: ${mine.deals.length}/${quota}* — quota met${deals}`
+        : `:hourglass_flowing_sand: *You: ${mine.deals.length}/${quota}*${deals}. ${remaining} more assignment${remaining === 1 ? '' : 's'} by Saturday 10am.`
+    );
+  } else {
+    lines.push("_You're not on the Ops Quota Roster (ops leads can add you in Notion)._");
+  }
+
+  const sorted = [...results].sort(
+    (a, b) => b.deals.length - a.deals.length || a.member.name.localeCompare(b.member.name)
+  );
+  if (sorted.length > 0) {
+    const met = sorted.filter((r) => r.met).length;
+    lines.push(
+      `*Team (${met}/${sorted.length} met):* ${sorted.map((r) => `${r.met ? '✅ ' : ''}${r.member.name} ${r.deals.length}/${quota}`).join(' · ')}`
+    );
+  }
+  lines.push('_Counts Pipeline deals you were made DRI on this week (new or re-assigned). `/sponsor claim <company>` or `/sponsor add <company> @you` to add one._');
+  return lines.join('\n');
+}
+
 function quotaMeta(weekEndIso: string): WinMeta {
   return { eventType: 'sponsor_quota_audit', key: 'week_end', value: weekEndIso };
 }
@@ -166,9 +226,13 @@ export async function runQuotaAudit(
   const client = makeSlackClient();
   const notion = new SponsorNotion();
 
+  // Bring the DRI ledger up to date first so re-assignments since the last hourly sync
+  // are dated (skipped in dry runs — no writes — so counts may lag by up to an hour).
+  if (!dryRun) await syncDriLedger(notion);
+
   const [members, deals, notionUsers] = await Promise.all([
     notion.queryQuotaRoster(),
-    notion.queryDealsCreatedSince(window.start.toISOString()),
+    notion.queryDealsEditedSince(window.start.toISOString()),
     notion.listNotionUsers(),
   ]);
   if (members.length === 0) {
 
@@ -93,6 +93,27 @@ function readRelationCount(prop: any): number {
   return (prop?.relation ?? []).length;
 }
 
+/** Name of the Pipeline rich-text property holding PERBot's DRI ledger. */
+export const DRI_LEDGER_PROP = 'DRI assigned';
+
+/** Parse the ledger text ("<userId> <ISO>" per line; malformed lines ignored). */
+export function parseDriLedger(text: string): Record<string, string> {
+  const ledger: Record<string, string> = {};
+  for (const line of text.split('\n')) {
+    const m = line.trim().match(/^([0-9a-f-]{32,36})\s+(\d{4}-\d{2}-\d{2}T[^\s]+)$/i);
+    if (m && !Number.isNaN(Date.parse(m[2]!))) ledger[m[1]!.toLowerCase()] = m[2]!;
+  }
+  return ledger;
+}
+
+/** Serialize a ledger back to the property text (sorted for stable diffs). */
+export function formatDriLedger(ledger: Record<string, string>): string {
+  return Object.entries(ledger)
+    .sort(([, a], [, b]) => a.localeCompare(b))
+    .map(([id, iso]) => `${id} ${iso}`)
+    .join('\n');
+}
+
 function parseBankRow(page: any): BankLeadRow {
   const p = page?.properties ?? {};
   const contactName = readRichText(p['Contact name']);
@@ -139,6 +160,7 @@ function parsePipelineRow(page: any): PipelineRow {
     nextActionDate: readDate(p['Next action date']),
     notes: readRichText(p['Notes']),
     createdTime: typeof page?.created_time === 'string' ? page.created_time : '',
+    driAssignedAt: parseDriLedger(readRichText(p[DRI_LEDGER_PROP])),
   };
 }
 
@@ -335,6 +357,18 @@ export class SponsorNotion {
       Type: { select: { name: input.type } },
       Category: { multi_select: input.categories.map((name) => ({ name })) },
       DRI: { people: input.driNotionIds.map((id) => ({ id })) },
+      // Seed the DRI ledger so the assignment is dated even before the hourly sync runs.
+      [DRI_LEDGER_PROP]: {
+        rich_text: [
+          {
+            text: {
+              content: formatDriLedger(
+                Object.fromEntries(input.driNotionIds.map((id) => [id.toLowerCase(), new Date().toISOString()]))
+              ),
+            },
+          },
+        ],
+      },
       'Bank source': { relation: [{ id: input.bankPageId }] },
       'Next action': { rich_text: [{ text: { content: input.nextAction.slice(0, 200) } }] },
       'Next action date': { date: { start: input.nextActionDateIso } },
@@ -402,11 +436,20 @@ export class SponsorNotion {
   }
 
   /**
-   * Deals whose Notion page was created at/after `sinceIso` (an ISO datetime) — feeds the
-   * weekly quota audit, which counts DRI assignments by when the deal entered the Pipeline.
+   * Deals edited (which includes created, and re-assigned — the DRI sync stamps the page)
+   * at/after `sinceIso` — a superset of every deal that can carry an assignment inside the
+   * quota window, so the audit doesn't have to scan the whole Pipeline.
    */
-  async queryDealsCreatedSince(sinceIso: string): Promise<PipelineRow[]> {
-    return this.queryPipeline({ timestamp: 'created_time', created_time: { on_or_after: sinceIso } });
+  async queryDealsEditedSince(sinceIso: string): Promise<PipelineRow[]> {
+    return this.queryPipeline({ timestamp: 'last_edited_time', last_edited_time: { on_or_after: sinceIso } });
+  }
+
+  /** Overwrite a deal's DRI ledger (`DRI assigned`) — used by the hourly DRI sync. */
+  async writeDriLedger(pageId: string, ledger: Record<string, string>): Promise<void> {
+    await this.client.pages.update({
+      page_id: pageId,
+      properties: { [DRI_LEDGER_PROP]: { rich_text: [{ text: { content: formatDriLedger(ledger).slice(0, 1900) } }] } } as any,
+    });
   }
 
   /** Deals flagged Reply pending by the Phase-3 flow — awaiting a DRI DM. */