pierre-review 0.1.23 → 0.1.24

package/dist/api/routes/insights.js

@@ -1,4 +1,4 @@
-import { getInsights } from '../../db/queries.js';
+import { getInsights, getRepoAnalytics } from '../../db/queries.js';
 import { accountIdOf } from '../plugins/auth.js';
 function parseIntList(raw) {
     if (!raw)
@@ -19,5 +19,17 @@ export async function insightsRoutes(app) {
             repoIds: parseIntList(q.repoIds),
         });
     });
+    // Heavier per-repo analytics for the drill-down chart panel — loaded on demand.
+    // Ownership-scoped: a repo not owned by the account 404s.
+    app.get('/api/insights/:repoId/analytics', async (req, reply) => {
+        const { repoId } = req.params;
+        const id = Number.parseInt(repoId, 10);
+        const data = Number.isFinite(id)
+            ? await getRepoAnalytics(accountIdOf(req), id)
+            : null;
+        if (!data)
+            return reply.code(404).send({ error: 'repo not found' });
+        return data;
+    });
 }
 //# sourceMappingURL=insights.js.map

package/dist/api/routes/me.js

@@ -8,7 +8,7 @@ const dismissSchema = {
         required: ['kind', 'refId'],
         additionalProperties: false,
         properties: {
-            kind: { type: 'string', enum: ['review_request', 'thread'] },
+            kind: { type: 'string', enum: ['review_request', 'thread', 'claude_review'] },
             refId: { type: 'integer' },
         },
     },
@@ -35,7 +35,8 @@ export async function meRoutes(app) {
         await dismissMyTurn(accountIdOf(req), kind, refId);
         return { status: 'ok' };
     });
-    // The "Done" tab: entries dismissed in the past 90 days (review_request + thread).
+    // The "Done" tab: entries dismissed in the past 90 days (review_request + thread
+    // + claude_review).
     app.get('/api/my-turn/done', async (req) => getCompletedDismissals(accountIdOf(req), 90));
     // Un-dismiss: move a completed entry back to the inbox.
     app.post('/api/my-turn/undismiss', { schema: dismissSchema }, async (req) => {

package/dist/db/queries.js

@@ -385,6 +385,10 @@ export async function getOpenPrs(filters) {
 }
 const INSIGHTS_MERGED_WINDOW_DAYS = 7;
 const INSIGHTS_REVIEW_WINDOW_DAYS = 30;
+// The "avg time a PR stays open" trend spans this many days back from now, in
+// weekly buckets (84 / 7 = 12 points).
+const INSIGHTS_CHART_WINDOW_DAYS = 84;
+const WEEK_MS = 7 * 86_400_000;
 function median(xs) {
     if (xs.length === 0)
         return null;
@@ -392,6 +396,34 @@ function median(xs) {
     const mid = Math.floor(s.length / 2);
     return s.length % 2 ? s[mid] : (s[mid - 1] + s[mid]) / 2;
 }
+// Bucket PR cycle times (openMs→closeMs) into weekly points over the chart window,
+// oldest first. Each point is the MEAN open-hours of the PRs that CLOSED that week;
+// a week with no closed PRs yields a null average (a gap in the trend line).
+function buildOpenDurationTrend(rows, windowStartMs, nowMs) {
+    const buckets = Math.round((nowMs - windowStartMs) / WEEK_MS);
+    const sums = new Array(buckets).fill(0);
+    const counts = new Array(buckets).fill(0);
+    for (const r of rows) {
+        if (r.closeMs < windowStartMs || r.closeMs > nowMs)
+            continue;
+        const hrs = (r.closeMs - r.openMs) / 3_600_000;
+        if (hrs < 0)
+            continue;
+        const idx = Math.min(buckets - 1, Math.floor((r.closeMs - windowStartMs) / WEEK_MS));
+        sums[idx] += hrs;
+        counts[idx] += 1;
+    }
+    const out = [];
+    for (let i = 0; i < buckets; i++) {
+        const c = counts[i];
+        out.push({
+            bucketStart: new Date(windowStartMs + i * WEEK_MS).toISOString(),
+            avgOpenHours: c > 0 ? Math.round((sums[i] / c) * 10) / 10 : null,
+            count: c,
+        });
+    }
+    return out;
+}
 /**
  * Per-repo snapshot for the Insights panel. Counts (open/draft/stalled) are current
  * state; merged is a 7-day window; time-to-first-review is a median over PRs opened
@@ -403,10 +435,12 @@ export async function getInsights(filters) {
     const now = Date.now();
     const mergedCutoff = new Date(now - INSIGHTS_MERGED_WINDOW_DAYS * 86_400_000);
     const reviewCutoff = new Date(now - INSIGHTS_REVIEW_WINDOW_DAYS * 86_400_000);
+    const chartWindowStartMs = now - INSIGHTS_CHART_WINDOW_DAYS * 86_400_000;
     const base = {
         mergedWindowDays: INSIGHTS_MERGED_WINDOW_DAYS,
         reviewWindowDays: INSIGHTS_REVIEW_WINDOW_DAYS,
         stallThresholdDays: config.stallThresholdDays,
+        chartWindowDays: INSIGHTS_CHART_WINDOW_DAYS,
         generatedAt: new Date().toISOString(),
     };
     const reposAll = await listRepos(accountId);
@@ -436,6 +470,35 @@ export async function getInsights(filters) {
     const mergedByRepo = new Map();
     for (const r of mergedRows)
         mergedByRepo.set(r.repoId, (mergedByRepo.get(r.repoId) ?? 0) + 1);
+    // PRs closed/merged within the chart window, for the per-repo "avg time open"
+    // trend. A merged PR's close instant is mergedAt; a plain-closed one's is closedAt.
+    const chartCutoff = new Date(chartWindowStartMs);
+    const closedConds = [
+        eq(pullRequests.accountId, accountId),
+        inArray(pullRequests.state, ['merged', 'closed']),
+        or(gte(pullRequests.mergedAt, chartCutoff), gte(pullRequests.closedAt, chartCutoff)),
+    ];
+    if (repoIds)
+        closedConds.push(inArray(pullRequests.repoId, repoIds));
+    const closedRows = await db
+        .select({
+        repoId: pullRequests.repoId,
+        openedAt: pullRequests.openedAt,
+        mergedAt: pullRequests.mergedAt,
+        closedAt: pullRequests.closedAt,
+    })
+        .from(pullRequests)
+        .where(and(...closedConds))
+        .execute();
+    const closedByRepo = new Map();
+    for (const r of closedRows) {
+        const close = r.mergedAt ?? r.closedAt;
+        if (!close)
+            continue;
+        const arr = closedByRepo.get(r.repoId) ?? [];
+        arr.push({ openMs: r.openedAt.getTime(), closeMs: close.getTime() });
+        closedByRepo.set(r.repoId, arr);
+    }
     // Time-to-first-review samples: PRs opened in the review window with a first review.
     const ttfrConds = [
         eq(pullRequests.accountId, accountId),
@@ -527,10 +590,269 @@ export async function getInsights(filters) {
                 : null,
             reviewLoad,
             openPrList,
+            openDurationTrend: buildOpenDurationTrend(closedByRepo.get(repo.id) ?? [], chartWindowStartMs, now),
         };
     });
     return { ...base, repos: repoInsights };
 }
+// Heavier per-repo analytics for the drill-down panel — computed on demand (only
+// when the panel opens). All series cover the last INSIGHTS_CHART_WINDOW_DAYS in
+// weekly buckets, except the distributions (categorical), the size/cycle scatter,
+// and the weekday×hour heatmap. Scoped to the account; returns null when the repo
+// isn't owned by the account (→ 404 at the route).
+export async function getRepoAnalytics(accountId, repoId) {
+    const repo = await getRepo(repoId, accountId);
+    if (!repo)
+        return null;
+    const now = Date.now();
+    const windowDays = INSIGHTS_CHART_WINDOW_DAYS;
+    const windowStartMs = now - windowDays * 86_400_000;
+    const windowStart = new Date(windowStartMs);
+    const nBuckets = Math.round((now - windowStartMs) / WEEK_MS);
+    const weekBuckets = [];
+    for (let i = 0; i < nBuckets; i++) {
+        weekBuckets.push(new Date(windowStartMs + i * WEEK_MS).toISOString());
+    }
+    const zeros = () => new Array(nBuckets).fill(0);
+    const bi = (ms) => Math.max(0, Math.min(nBuckets - 1, Math.floor((ms - windowStartMs) / WEEK_MS)));
+    const inWin = (ms) => ms >= windowStartMs && ms <= now;
+    const inc = (arr, i) => {
+        arr[i] = (arr[i] ?? 0) + 1;
+    };
+    const addv = (arr, i, v) => {
+        arr[i] = (arr[i] ?? 0) + v;
+    };
+    // ---- PRs relevant to the window: opened/closed in window, or still open ----
+    const prRows = await db
+        .select({
+        number: pullRequests.number,
+        openedAt: pullRequests.openedAt,
+        firstReviewAt: pullRequests.firstReviewAt,
+        mergedAt: pullRequests.mergedAt,
+        closedAt: pullRequests.closedAt,
+        lastCommitAt: pullRequests.lastCommitAt,
+        additions: pullRequests.additions,
+        deletions: pullRequests.deletions,
+    })
+        .from(pullRequests)
+        .where(and(eq(pullRequests.accountId, accountId), eq(pullRequests.repoId, repoId), or(and(isNull(pullRequests.mergedAt), isNull(pullRequests.closedAt)), gte(pullRequests.openedAt, windowStart), gte(pullRequests.mergedAt, windowStart), gte(pullRequests.closedAt, windowStart))))
+        .execute();
+    const opened = zeros();
+    const mergedSeries = zeros();
+    const closedSeries = zeros();
+    const open = zeros();
+    const stalled = zeros();
+    const stallMs = config.stallThresholdDays * 86_400_000;
+    const ttfrByBucket = Array.from({ length: nBuckets }, () => []);
+    const cbA = zeros();
+    const cbB = zeros();
+    const cbN = zeros();
+    const LAT_BINS = [
+        { label: '<1h', max: 1 },
+        { label: '1–4h', max: 4 },
+        { label: '4–24h', max: 24 },
+        { label: '1–3d', max: 72 },
+        { label: '>3d', max: Infinity },
+    ];
+    const latCounts = new Array(LAT_BINS.length).fill(0);
+    const SIZE_BINS = [
+        { label: 'XS <10', max: 10 },
+        { label: 'S <50', max: 50 },
+        { label: 'M <200', max: 200 },
+        { label: 'L <500', max: 500 },
+        { label: 'XL 500+', max: Infinity },
+    ];
+    const sizeCounts = new Array(SIZE_BINS.length).fill(0);
+    const binOf = (bins, v) => {
+        for (let b = 0; b < bins.length; b++)
+            if (v < bins[b].max)
+                return b;
+        return bins.length - 1;
+    };
+    const sizeVsCycle = [];
+    // Time-open samples per LOC bucket, over ALL PRs closed in the window (uncapped,
+    // unlike sizeVsCycle), for the median-by-size view.
+    const sizeBucketDur = SIZE_BINS.map(() => []);
+    for (const p of prRows) {
+        const oMs = p.openedAt.getTime();
+        const closeDate = p.mergedAt ?? p.closedAt;
+        const cMs = closeDate ? closeDate.getTime() : null;
+        if (inWin(oMs))
+            inc(opened, bi(oMs));
+        if (p.mergedAt && inWin(p.mergedAt.getTime()))
+            inc(mergedSeries, bi(p.mergedAt.getTime()));
+        if (!p.mergedAt && p.closedAt && inWin(p.closedAt.getTime())) {
+            inc(closedSeries, bi(p.closedAt.getTime()));
+        }
+        // Backlog: was this PR open at each week's end, and stalled (no recent commit)?
+        for (let i = 0; i < nBuckets; i++) {
+            const snap = Math.min(windowStartMs + (i + 1) * WEEK_MS, now);
+            if (oMs <= snap && (cMs == null || cMs > snap)) {
+                inc(open, i);
+                const lastAct = p.lastCommitAt ? p.lastCommitAt.getTime() : oMs;
+                if (lastAct < snap - stallMs)
+                    inc(stalled, i);
+            }
+        }
+        if (p.firstReviewAt && inWin(oMs)) {
+            const hrs = (p.firstReviewAt.getTime() - oMs) / 3_600_000;
+            if (hrs >= 0)
+                ttfrByBucket[bi(oMs)].push(hrs);
+        }
+        if (p.firstReviewAt && inWin(p.firstReviewAt.getTime())) {
+            const hrs = (p.firstReviewAt.getTime() - oMs) / 3_600_000;
+            if (hrs >= 0)
+                latCounts[binOf(LAT_BINS, hrs)]++;
+        }
+        if (cMs != null && inWin(cMs)) {
+            const total = (cMs - oMs) / 3_600_000;
+            if (total >= 0) {
+                const idx = bi(cMs);
+                inc(cbN, idx);
+                if (p.firstReviewAt) {
+                    addv(cbA, idx, Math.max(0, (p.firstReviewAt.getTime() - oMs) / 3_600_000));
+                    addv(cbB, idx, Math.max(0, (cMs - p.firstReviewAt.getTime()) / 3_600_000));
+                }
+                else {
+                    addv(cbA, idx, total);
+                }
+                const loc = p.additions + p.deletions;
+                sizeVsCycle.push({
+                    prNumber: p.number,
+                    loc,
+                    hoursOpen: Math.round(total * 10) / 10,
+                    merged: p.mergedAt != null,
+                });
+                sizeBucketDur[binOf(SIZE_BINS, loc)].push(total);
+            }
+        }
+        if (inWin(oMs))
+            sizeCounts[binOf(SIZE_BINS, p.additions + p.deletions)]++;
+    }
+    // ---- reviews in window: verdict mix + per-reviewer load ----
+    const reviewRows = await db
+        .select({
+        reviewerId: reviews.authorId,
+        state: reviews.state,
+        submittedAt: reviews.submittedAt,
+    })
+        .from(reviews)
+        .innerJoin(pullRequests, eq(pullRequests.id, reviews.prId))
+        .where(and(eq(pullRequests.accountId, accountId), eq(pullRequests.repoId, repoId), gte(reviews.submittedAt, windowStart)))
+        .execute();
+    const verdicts = {
+        approved: zeros(),
+        changes_requested: zeros(),
+        commented: zeros(),
+        dismissed: zeros(),
+    };
+    const reviewerWeekly = new Map();
+    for (const r of reviewRows) {
+        const ms = r.submittedAt.getTime();
+        if (!inWin(ms))
+            continue;
+        const idx = bi(ms);
+        if (r.state === 'approved')
+            inc(verdicts.approved, idx);
+        else if (r.state === 'changes_requested')
+            inc(verdicts.changes_requested, idx);
+        else if (r.state === 'commented')
+            inc(verdicts.commented, idx);
+        else if (r.state === 'dismissed')
+            inc(verdicts.dismissed, idx);
+        if (r.reviewerId != null) {
+            const arr = reviewerWeekly.get(r.reviewerId) ?? zeros();
+            inc(arr, idx);
+            reviewerWeekly.set(r.reviewerId, arr);
+        }
+    }
+    const reviewerEntries = [...reviewerWeekly.entries()]
+        .map(([userId, weekly]) => ({ userId, weekly, total: weekly.reduce((a, b) => a + b, 0) }))
+        .sort((a, b) => b.total - a.total);
+    const TOP_REVIEWERS = 6;
+    const reviewerLoad = reviewerEntries
+        .slice(0, TOP_REVIEWERS)
+        .map((e) => ({ userId: e.userId, total: e.total, weekly: e.weekly }));
+    const rest = reviewerEntries.slice(TOP_REVIEWERS);
+    if (rest.length > 0) {
+        const otherWeekly = zeros();
+        for (const e of rest)
+            for (let i = 0; i < nBuckets; i++)
+                addv(otherWeekly, i, e.weekly[i] ?? 0);
+        reviewerLoad.push({
+            userId: -1,
+            total: otherWeekly.reduce((a, b) => a + b, 0),
+            weekly: otherWeekly,
+        });
+    }
+    // ---- review threads in window: derived-state mix by createdAt week ----
+    const threadRows = await db
+        .select({ state: reviewThreads.derivedState, createdAt: reviewThreads.createdAt })
+        .from(reviewThreads)
+        .innerJoin(pullRequests, eq(pullRequests.id, reviewThreads.prId))
+        .where(and(eq(pullRequests.accountId, accountId), eq(pullRequests.repoId, repoId), gte(reviewThreads.createdAt, windowStart)))
+        .execute();
+    const threadMix = {
+        resolved: zeros(),
+        likely_addressed: zeros(),
+        replied_unresolved: zeros(),
+        untouched: zeros(),
+    };
+    for (const t of threadRows) {
+        const ms = t.createdAt.getTime();
+        if (!inWin(ms))
+            continue;
+        inc(threadMix[t.state], bi(ms));
+    }
+    // ---- activity heatmap: events by weekday×hour (UTC) ----
+    const eventRows = await db
+        .select({ occurredAt: events.occurredAt })
+        .from(events)
+        .where(and(eq(events.accountId, accountId), eq(events.repoId, repoId), gte(events.occurredAt, windowStart)))
+        .execute();
+    const activityHeatmap = new Array(168).fill(0);
+    for (const e of eventRows) {
+        const d = e.occurredAt;
+        if (!inWin(d.getTime()))
+            continue;
+        activityHeatmap[d.getUTCDay() * 24 + d.getUTCHours()]++;
+    }
+    const round1 = (x) => Math.round(x * 10) / 10;
+    return {
+        repoId: repo.id,
+        repoFullName: repo.fullName,
+        windowDays,
+        stallThresholdDays: config.stallThresholdDays,
+        generatedAt: new Date().toISOString(),
+        weekBuckets,
+        throughput: { opened, merged: mergedSeries, closed: closedSeries },
+        backlog: { open, stalled },
+        reviewLatencyTrend: {
+            medianHours: ttfrByBucket.map((a) => {
+                const m = median(a);
+                return m == null ? null : round1(m);
+            }),
+            count: ttfrByBucket.map((a) => a.length),
+        },
+        cycleBreakdown: {
+            toFirstReview: cbA.map((s, i) => (cbN[i] ? round1(s / cbN[i]) : 0)),
+            reviewToMerge: cbB.map((s, i) => (cbN[i] ? round1(s / cbN[i]) : 0)),
+            count: cbN,
+        },
+        reviewLatencyDist: LAT_BINS.map((b, i) => ({ label: b.label, count: latCounts[i] })),
+        threadMix,
+        reviewVerdicts: verdicts,
+        reviewerLoad,
+        sizeDist: SIZE_BINS.map((b, i) => ({ label: b.label, count: sizeCounts[i] })),
+        sizeVsCycle: sizeVsCycle.slice(0, 500),
+        sizeCycleByBucket: SIZE_BINS.map((b, i) => {
+            const arr = sizeBucketDur[i];
+            const m = median(arr);
+            return { label: b.label, medianHours: m == null ? null : round1(m), count: arr.length };
+        }),
+        activityHeatmap,
+    };
+}
 // ---- merge-rights inference ----
 // Distinct users who have merged a PR INTO THE DEFAULT BRANCH per repo (across
 // ALL synced history, not the timeline window). We treat "has merged into the
@@ -632,6 +954,15 @@ async function ownsDismissRef(accountId, kind, refId) {
             .execute();
         return rows.length > 0;
     }
+    if (kind === 'claude_review') {
+        const rows = await db
+            .select({ id: claudeReviews.id })
+            .from(claudeReviews)
+            .where(and(eq(claudeReviews.id, refId), eq(claudeReviews.accountId, accountId)))
+            .limit(1)
+            .execute();
+        return rows.length > 0;
+    }
     const rows = await db
         .select({ id: reviewThreads.id })
         .from(reviewThreads)
@@ -664,10 +995,10 @@ export async function undismissMyTurn(accountId, kind, refId) {
         .execute();
 }
 // The My Turn "Done" tab: entries the user dismissed within the past `daysBefore`
-// days (default 90), newest-dismissed first. Covers only the dismissal-backed kinds
-// (review_request + thread); "Your PRs" are cleared via mark-viewed, not a
-// restorable dismissal. Rebuilds each entry by joining the dismissal's refId back to
-// its PR / thread. accountId-scoped throughout.
+// days (default 90), newest-dismissed first. Covers the dismissal-backed kinds
+// (review_request + thread + claude_review); "Your PRs" are cleared via mark-viewed,
+// not a restorable dismissal. Rebuilds each entry by joining the dismissal's refId
+// back to its PR / thread / Claude-review run. accountId-scoped throughout.
 export async function getCompletedDismissals(accountId, daysBefore = 90) {
     const cutoff = new Date(Date.now() - daysBefore * 24 * 60 * 60 * 1000);
     const dismissals = await db
@@ -679,6 +1010,7 @@ export async function getCompletedDismissals(accountId, daysBefore = 90) {
         return { items: [], users: [] };
     const reviewDismissals = dismissals.filter((d) => d.kind === 'review_request');
     const threadDismissals = dismissals.filter((d) => d.kind === 'thread');
+    const claudeDismissals = dismissals.filter((d) => d.kind === 'claude_review');
     const items = [];
     const referencedUsers = new Set();
     // review_request dismissals → their PRs (account-scoped).
@@ -756,6 +1088,43 @@ export async function getCompletedDismissals(accountId, daysBefore = 90) {
             });
         }
     }
+    // claude_review dismissals → their run + parent PR (account-scoped). History is
+    // kept, so an old run still resolves even after a newer run superseded it.
+    if (claudeDismissals.length > 0) {
+        const reviewIds = claudeDismissals.map((d) => d.refId);
+        const runRows = await db
+            .select({
+            reviewId: claudeReviews.id,
+            prId: claudeReviews.prId,
+            owner: repos.owner,
+            name: repos.name,
+            prNumber: pullRequests.number,
+            prTitle: pullRequests.title,
+            verdict: claudeReviews.verdict,
+        })
+            .from(claudeReviews)
+            .innerJoin(pullRequests, eq(pullRequests.id, claudeReviews.prId))
+            .innerJoin(repos, eq(repos.id, pullRequests.repoId))
+            .where(and(eq(claudeReviews.accountId, accountId), inArray(claudeReviews.id, reviewIds)))
+            .execute();
+        const byId = new Map(runRows.map((r) => [r.reviewId, r]));
+        for (const d of claudeDismissals) {
+            const r = byId.get(d.refId);
+            if (!r)
+                continue;
+            items.push({
+                kind: 'claude_review',
+                reviewId: r.reviewId,
+                prId: r.prId,
+                repoFullName: `${r.owner}/${r.name}`,
+                prNumber: r.prNumber,
+                prTitle: r.prTitle,
+                verdict: r.verdict,
+                githubUrl: `https://github.com/${r.owner}/${r.name}/pull/${r.prNumber}`,
+                dismissedAt: d.dismissedAt.toISOString(),
+            });
+        }
+    }
     // Newest-dismissed first.
     items.sort((a, b) => b.dismissedAt.localeCompare(a.dismissedAt));
     const usersList = referencedUsers.size > 0
@@ -811,11 +1180,16 @@ export async function getMyTurn(accountId) {
         .execute();
     const reviewDismissedAt = new Map();
     const threadDismissedAt = new Map();
+    // Dismissed Claude-review run ids. Keyed by run id (not PR id): a fresh run gets
+    // a new id, so it naturally re-appears without a timestamp comparison.
+    const claudeDismissedIds = new Set();
     for (const d of dismissals) {
         if (d.kind === 'review_request')
             reviewDismissedAt.set(d.refId, d.dismissedAt);
         else if (d.kind === 'thread')
             threadDismissedAt.set(d.refId, d.dismissedAt);
+        else if (d.kind === 'claude_review')
+            claudeDismissedIds.add(d.refId);
     }
     const meta = (prId) => openRows.find((p) => p.id === prId);
     const toMyTurnPr = (t) => {
@@ -871,8 +1245,9 @@ export async function getMyTurn(accountId) {
             referencedUsers.add(ta.lastReplyAuthorId);
     }
     // Completed-but-unactioned Claude reviews (local-only feature; empty otherwise).
+    // A manual "Done" hides the run until a newer run finishes (see claudeDismissedIds).
     const claudeReviewsToAction = config.claudeReviewEnabled
-        ? await getUnactionedClaudeReviews(accountId)
+        ? (await getUnactionedClaudeReviews(accountId)).filter((c) => !claudeDismissedIds.has(c.reviewId))
         : [];
     const users = referencedUsers.size > 0
         ? (await db

package/dist/db/schema.pg.js

@@ -151,7 +151,9 @@ export const myTurnDismissals = pgTable('my_turn_dismissals', {
     accountId: integer('account_id')
         .notNull()
         .references(() => accounts.id),
-    kind: text('kind', { enum: ['review_request', 'thread'] }).notNull(),
+    kind: text('kind', {
+        enum: ['review_request', 'thread', 'claude_review'],
+    }).notNull(),
     refId: integer('ref_id').notNull(),
     dismissedAt: timestamp('dismissed_at', {
         withTimezone: true,

package/dist/db/schema.sqlite.js

@@ -164,17 +164,20 @@ export const prViews = sqliteTable('pr_views', {
     lastViewedSha: text('last_viewed_sha'),
     lastViewedAt: integer('last_viewed_at', { mode: 'timestamp' }).notNull(),
 });
-// Manual dismissals of "my turn" entries. `refId` is a PR id (review_request)
-// or a review-thread id (thread). The dismissal is honoured only while no newer
-// activity has happened — getMyTurn compares dismissedAt against the PR's
-// updatedAt / the thread's last reply, so it auto-resurfaces. `accountId` scopes
-// the dismissal set per tenant.
+// Manual dismissals of "my turn" entries. `refId` is a PR id (review_request),
+// a review-thread id (thread), or a Claude-review run id (claude_review). The
+// dismissal is honoured only while no newer activity has happened — getMyTurn
+// compares dismissedAt against the PR's updatedAt / the thread's last reply, and a
+// claude_review is keyed by run id so a fresh run is a new (undismissed) entry.
+// `accountId` scopes the dismissal set per tenant.
 export const myTurnDismissals = sqliteTable('my_turn_dismissals', {
     id: integer('id').primaryKey({ autoIncrement: true }),
     accountId: integer('account_id')
         .notNull()
         .references(() => accounts.id),
-    kind: text('kind', { enum: ['review_request', 'thread'] }).notNull(),
+    kind: text('kind', {
+        enum: ['review_request', 'thread', 'claude_review'],
+    }).notNull(),
     refId: integer('ref_id').notNull(),
     dismissedAt: integer('dismissed_at', { mode: 'timestamp' }).notNull(),
 }, (t) => ({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pierre-review",
-  "version": "0.1.23",
+  "version": "0.1.24",
   "description": "Dashboard for tracking your team's GitHub PR activity across repos — local (SQLite + gh) or self-hosted multi-tenant cloud (Postgres + GitHub App).",
   "type": "module",
   "author": "Alex Wakeman",