limn-review 0.1.142 → 0.1.144

package/dist/config.js

@@ -378,6 +378,9 @@ export const config = {
     // AUTOMATIC ticket reviews (trigger 'auto' / 'cascade') per workspace per UTC day. Not shared with
     // the PR review's own auto cap. Manual runs never count. Default = shared TICKET_REVIEW_DAILY_CAP.
     ticketReviewDailyCap: intFromEnv('TICKET_REVIEW_DAILY_CAP', 20),
+    // Automatic re-checks of ONE ticket that only follow pushes, per UTC day (review/ticket-review/sweep.ts).
+    // A PR joining, leaving or merging, or the story changing, is not limited by it.
+    ticketReviewPushRechecksPerDay: intFromEnv('TICKET_REVIEW_PUSH_RECHECKS_PER_DAY', 3),
     // ---- CI review (one run per (PR, head, failing-check set) — review/ci-review/) ----
     // Its OWN spend cap and turn cap: a CI run reads log excerpts and the files they point at, nothing
     // more. Env only — no route sets it.

package/dist/db/client.js

@@ -3,6 +3,7 @@
 // The app talks to `db` through the async surface only (`await builder` / `.execute()` /
 // `.returning().execute()` / runTransaction). Postgres support is gone; the query layer keeps
 // that style because nothing gains from rewriting it.
+import { AsyncLocalStorage } from 'node:async_hooks';
 import { chmodSync, mkdirSync } from 'node:fs';
 import { dirname } from 'node:path';
 import Database from 'better-sqlite3';
@@ -40,23 +41,51 @@ export async function closeDb() {
 }
 // The one transaction entry. better-sqlite3 rejects async transaction callbacks ("Transaction
 // function cannot return a promise"), so this wraps a manual BEGIN/COMMIT around the awaited
-// (synchronously-resolving) drizzle ops — no other macrotask interleaves between BEGIN and
-// COMMIT because the callback only awaits in-process sqlite work (no real I/O).
+// (synchronously-resolving) drizzle ops. The callback only awaits in-process sqlite work, so no
+// MACROtask interleaves — but MICROtasks do: two runTransaction calls started by separate async
+// chains in the same tick both reached BEGIN, and the second threw "cannot start a transaction
+// within a transaction" (two ticket runs started in the same second, 2026-10-28). So callers queue
+// on ONE in-process lock, in call order.
+// ⚠ A NESTED call (runTransaction inside a runTransaction callback) would wait on itself for ever;
+// it throws instead, as the bare BEGIN always did. Detected by the holder's token in async context,
+// so work the callback merely STARTED (fire-and-forget) that runs a transaction after the commit
+// waits its turn rather than throwing.
+let txTail = Promise.resolve();
+let txHolder = null;
+const txContext = new AsyncLocalStorage();
 export async function runTransaction(fn) {
-    sqliteConn.exec('BEGIN');
+    const outer = txContext.getStore();
+    if (outer != null && outer === txHolder) {
+        throw new Error('runTransaction: a nested transaction is not supported');
+    }
+    const prev = txTail;
+    let release;
+    txTail = new Promise((resolve) => (release = resolve));
+    await prev;
+    const token = Symbol('tx');
+    txHolder = token;
     try {
-        const result = await fn(db);
-        sqliteConn.exec('COMMIT');
-        return result;
+        return await txContext.run(token, async () => {
+            sqliteConn.exec('BEGIN');
+            try {
+                const result = await fn(db);
+                sqliteConn.exec('COMMIT');
+                return result;
+            }
+            catch (err) {
+                try {
+                    sqliteConn.exec('ROLLBACK');
+                }
+                catch {
+                    /* rollback best-effort */
+                }
+                throw err;
+            }
+        });
     }
-    catch (err) {
-        try {
-            sqliteConn.exec('ROLLBACK');
-        }
-        catch {
-            /* rollback best-effort */
-        }
-        throw err;
+    finally {
+        txHolder = null;
+        release();
     }
 }
 //# sourceMappingURL=client.js.map

package/dist/review/claude-review/auto-post.js

@@ -58,6 +58,7 @@
 // ⚠ Manual runs are never auto-posted: a review you start yourself keeps the Post button.
 // ⚠ Never throws: auto-posting failing must never touch the review.
 import { and, desc, eq, inArray, isNull, lt } from 'drizzle-orm';
+import { clipAtSentence as clipAtSentenceShared } from '../../shared/index.js';
 import {} from '../../shared/index.js';
 import { readWorkspaceAutoPostForPr } from './auto-settings.js';
 import { similarTitles } from './settled-by-reply.js';
@@ -222,14 +223,23 @@ export function liftBlockMessage(by = 'Claude') {
     return `${by}'s blocking findings are fixed.`;
 }
 export const LIFT_BLOCK_MESSAGE = liftBlockMessage('Claude');
-/** The review body's lead: the summary's first plain sentence, else a count. `by` names the provider
- *  that ran the review (default Claude — its text is unchanged). */
+// The lead's ceiling. A summary's first paragraph is normally far shorter; past this it is cut at the
+// last sentence end that fits, never mid-sentence (GitHub allows 65,536 characters in a review body).
+const LEAD_MAX_CHARS = 3_000;
+/** Cut `text` to ≤ `max` characters at the last sentence end that fits; failing that, at the last space
+ *  (with "…"). Text that fits is returned whole. The fold is shared (`clipAtSentence`, shared prose.ts). */
+export function clipAtSentence(text, max = LEAD_MAX_CHARS) {
+    return clipAtSentenceShared(text, max);
+}
+/** The review body's lead: the summary's first plain paragraph (whole, unless it passes
+ *  LEAD_MAX_CHARS), else a count. `by` names the provider that ran the review (default Claude — its
+ *  text is unchanged). */
 export function autoReviewBodyLead(summary, commentCount, by = 'Claude') {
     for (const raw of (summary ?? '').split('\n')) {
         const line = raw.trim();
         if (line === '' || /^([-*+]|\d+[.)])\s/.test(line) || line.startsWith('#'))
             continue;
-        return line.length > 400 ? `${line.slice(0, 399)}…` : line;
+        return clipAtSentence(line);
     }
     if (commentCount === 0)
         return `Reviewed by ${by}.`;

package/dist/review/claude-review/chat-explain.js

@@ -1,4 +1,4 @@
-import { CLAUDE_REVIEW_CHAT_MAX_PINS, } from '../../shared/index.js';
+import { CLAUDE_REVIEW_CHAT_MAX_PINS, criterionTextOnly, } from '../../shared/index.js';
 import { loadZod } from '../../ai/runtime.js';
 // Per-field caps on what the model sends back (it is stored and rendered as plain text).
 const CARD_FIELD_CHARS = 4_000;
@@ -69,8 +69,11 @@ export function findingPinLabel(f) {
     return `${SEVERITY_WORD[f.severity] ?? 'Finding'} · ${oneLine(f.title, LABEL_TITLE_CHARS)}`;
 }
 export function storyPinLabel(item, ticketKey) {
-    const head = ticketKey ? `${ticketKey} ${item.ref}` : item.ref;
-    return `${head} · ${STORY_STATUS_WORD[item.status]} · ${oneLine(item.title, LABEL_TITLE_CHARS)}`;
+    // A missing item's 'M1'… ref is internal (the reader never sees it): it is named by its title only.
+    const missing = item.status === 'missing';
+    const head = [ticketKey, missing ? null : item.ref].filter((x) => x != null && x !== '').join(' ');
+    const title = oneLine(missing ? item.title : criterionTextOnly(item.title, item.ref), LABEL_TITLE_CHARS);
+    return `${head !== '' ? `${head} · ` : ''}${STORY_STATUS_WORD[item.status]} · ${title}`;
 }
 const clip = (t, max) => {
     const s = t.replace(/\s+$/, '');

package/dist/review/claude-review/manager.js

@@ -540,7 +540,7 @@ function runEnded(item, end) {
     // trigger never throws and only queues, so it can neither block nor fail this review.
     if (succeeded) {
         void import('../diagrams/trigger.js')
-            .then((m) => m.maybeDrawDiagramsAfterReview(ctx, { accountId: item.accountId, prId, reviewTrigger: item.trigger }))
+            .then(async (m) => m.logTriggerLimits(ctx, prId, await m.maybeDrawDiagramsAfterReview(ctx, { accountId: item.accountId, prId, reviewTrigger: item.trigger })))
             .catch((err) => ctx.log.warn(`sequence diagrams pr ${prId}: ${err instanceof Error ? err.message : String(err)}`));
     }
     // AUTO FIX: a SUCCEEDED auto run may start a review-seeded fix on the reader's OWN PR

package/dist/review/claude-review/ticket.js

@@ -1,4 +1,4 @@
-import { CLAUDE_REVIEW_TICKET_MAX_CRITERIA, storedList, ticketRef } from '../../shared/index.js';
+import { CLAUDE_REVIEW_TICKET_MAX_CRITERIA, criterionTextForMatch, storedList, ticketRef } from '../../shared/index.js';
 export const TICKET_SUMMARY_CHARS = 1_000;
 export const TICKET_EXPLANATION_CHARS = 1_000;
 export const TICKET_GAP_TITLE_CHARS = 200;
@@ -143,6 +143,9 @@ export function storyMatchKey(f) {
     if (!f.story)
         return null;
     const kind = /^M\d+$/.test(f.story.ref) ? 'missing' : 'criterion';
-    return `${kind}\u0000${f.title.replace(/\s+/g, ' ').trim().toLowerCase()}`;
+    // A criterion's leading "AC2: " is not part of its identity: older runs stored it in the title,
+    // newer ones drop it (reconcile.ts), and the two must stay one item (its posted state carries over).
+    const text = kind === 'criterion' ? criterionTextForMatch(f.title) : f.title;
+    return `${kind}\u0000${text.replace(/\s+/g, ' ').trim().toLowerCase()}`;
 }
 //# sourceMappingURL=ticket.js.map

package/dist/review/diagrams/fingerprint.js

@@ -1,4 +1,5 @@
 import { createHash } from 'node:crypto';
+import { repeatRunLimit } from '../../shared/index.js';
 import { codeLocFor, isNonCodeFile } from '../../db/code-loc.js';
 // "IS THIS DIAGRAM STILL TRUE?" and "SHOULD A FINISHED REVIEW DRAW ONE?" — PURE, clock-free.
 //
@@ -51,8 +52,10 @@ export function diagramSkipReason(a) {
         return 'drawn';
     if (a.inFlight)
         return 'in_flight';
-    if (a.usedToday >= a.dailyCap)
+    if (a.usedToday >= (a.redraw != null ? repeatRunLimit(a.dailyCap) : a.dailyCap))
         return 'daily_cap';
+    if (a.redraw != null && a.redraw.subjectDrawsToday >= a.redraw.subjectCap)
+        return 'redraw_limit';
     return null;
 }
 //# sourceMappingURL=fingerprint.js.map

package/dist/review/diagrams/persist.js

@@ -250,6 +250,33 @@ export async function countReviewDiagramsSince(ctx, accountId, dayStartMs) {
         .execute());
     return rows.length;
 }
+/**
+ * One subject's draw history for the trigger's REDRAW rule (trigger.ts): how many review-started rows
+ * of it count against the cap today, and the members of its newest drawn row (any trigger, any status,
+ * no server refusal) — null members when that row has none (a PR diagram); `drawnBefore` false when
+ * the subject was never drawn.
+ */
+export async function subjectDrawHistory(ctx, accountId, kind, subject, dayStartMs) {
+    const d = t(ctx);
+    const today = (await ctx.db
+        .select({ id: d.id })
+        .from(d)
+        .where(and(eq(d.accountId, accountId), eq(d.kind, kind), eq(d.subject, subject), eq(d.trigger, 'review'), or(isNull(d.refusal), notInArray(d.refusal, [...FREE_REFUSALS])), gte(d.createdAt, new Date(dayStartMs))))
+        .execute());
+    const last = (await ctx.db
+        .select({ members: d.members })
+        .from(d)
+        .where(and(eq(d.accountId, accountId), eq(d.kind, kind), eq(d.subject, subject), isNull(d.refusal)))
+        .orderBy(desc(d.createdAt), desc(d.id))
+        .limit(1)
+        .execute());
+    const row = last[0];
+    return {
+        drawsToday: today.length,
+        drawnBefore: row != null,
+        lastMemberIds: row?.members != null ? row.members.map((m) => m.prId) : null,
+    };
+}
 // ---- the wire ----
 export function toDiagramView(row, current) {
     const iso = (v) => v == null ? null : (v instanceof Date ? v : new Date(v)).toISOString();

package/dist/review/diagrams/routes.js

@@ -4,7 +4,7 @@ import { AGENTIC_AI_ENABLED } from '../claude-review/manager.js';
 import { prDiagramFingerprint, storedCodeAnswer, storyDiagramFingerprint } from './fingerprint.js';
 import { liveStoryMembers, startDiagram } from './manager.js';
 import { getDiagramPrContext, latestDiagram, latestSucceededDiagram, toDiagramView, } from './persist.js';
-import { MAX_TICKETS, toDiagramMembers } from './trigger.js';
+import { MAX_TICKETS, diagramAutoSkip, toDiagramMembers } from './trigger.js';
 import { providerName } from '../../ai/prompt-tools.js';
 // THE DESIGN-DIAGRAM API (CORE, free, LOCAL ONLY; paths keep "sequence-diagrams") — docs/API.md § Design diagrams. Registered by
 // `registerAgenticRoutes` (review/agentic.ts), so absent in cloud and under LIMN_AI_DISABLED; the
@@ -43,13 +43,17 @@ function featureOff(reply) {
 /** What to draw and, beside it, the newest run when that is another one. `liveFp` null ⇒ not current. */
 export async function slotFor(ctx, accountId, kind, subject, liveFp) {
     const latest = await latestDiagram(ctx, accountId, kind, subject);
+    // Why the last finished review did not draw it at the live inputs (a daily or redraw limit).
+    const skipped = diagramAutoSkip(accountId, kind, subject, liveFp);
+    const autoSkipped = skipped != null ? { autoSkipped: skipped } : {};
     if (latest == null)
-        return { diagram: null, latest: null };
+        return { diagram: null, latest: null, ...autoSkipped };
     const good = latest.status === 'succeeded' ? latest : await latestSucceededDiagram(ctx, accountId, kind, subject);
     const view = (r) => toDiagramView(r, liveFp != null && r.fingerprint === liveFp);
     return {
         diagram: good != null ? view(good) : null,
         latest: good != null && good.id === latest.id ? null : view(latest),
+        ...autoSkipped,
     };
 }
 async function storySlot(ctx, accountId, ident, ticketKey) {

package/dist/review/diagrams/trigger.js

@@ -1,9 +1,9 @@
-import { parseTicketIdent } from '../../shared/index.js';
+import { SEQUENCE_DIAGRAM_SUBJECT_DAILY_DRAWS, parseTicketIdent, } from '../../shared/index.js';
 import { config } from '../../config.js';
 import { getTicketSource } from '../../tracker/ticket-source.js';
 import { automaticRunAllowed } from '../budget-gate.js';
 import { diagramSkipReason, prDiagramFingerprint, storedCodeAnswer, storyDiagramFingerprint, } from './fingerprint.js';
-import { countReviewDiagramsSince, diagramExistsAt, diagramsSwitchedOnForPr, getDiagramPrContext, getPrFileStats, markDiagramRefused, insertQueuedDiagram, } from './persist.js';
+import { countReviewDiagramsSince, diagramExistsAt, diagramsSwitchedOnForPr, getDiagramPrContext, getPrFileStats, markDiagramRefused, insertQueuedDiagram, subjectDrawHistory, } from './persist.js';
 // "A REVIEW JUST FINISHED — DRAW ITS DIAGRAMS?" The one hook between Claude Review and this process.
 // claude-review/manager.ts calls it fire-and-forget after EVERY succeeded run, MANUAL OR AUTO, and
 // nothing it does can reach the review: it never throws (every error is logged and swallowed) and it
@@ -18,6 +18,15 @@ import { countReviewDiagramsSince, diagramExistsAt, diagramsSwitchedOnForPr, get
 //                  at most MAX_TICKETS. A ticket with MORE THAN ONE open or merged PR queues ONE
 //                  'story' diagram under the same rules, its fingerprint over every member's head and
 //                  state — so a push to ANY member redraws it after that member's next review.
+// ⚠ A REDRAW IS LIMITED (2026-10-28: one story drawn 11 times and one PR 9 times spent the cap of 30
+//                  by 14:52, and every later review drew nothing, silently). A subject drawn before —
+//                  a story with the SAME pull requests — is drawn at most SEQUENCE_DIAGRAM_SUBJECT_DAILY_DRAWS
+//                  (2) times a UTC day, its first draw included, and never takes the cap's last slots
+//                  (shared `repeatRunLimit`). A first draw, or a story whose PRs changed, is held only
+//                  by the cap. A skip for a limit is LOGGED (`logTriggerLimits`) and kept in memory
+//                  for the slot (`diagramAutoSkip` → `autoSkipped`), so the pane can say why.
+// After a TICKET REVIEW succeeds (`maybeDrawStoryDiagramAfterTicketReview`), its story is asked again
+// under the same rules: a PR's ticket link can land after that PR's own review ended.
 //
 // ⚠ THE PER-WORKSPACE SWITCH (`workspaces.auto_diagrams_enabled`, migration 0126, ON by default):
 // switched off for the PR's workspace ⇒ 'switched_off' and nothing is queued or stored. It gates
@@ -36,6 +45,7 @@ const defaultDeps = {
     switchedOn: diagramsSwitchedOnForPr,
     exists: diagramExistsAt,
     usedToday: countReviewDiagramsSince,
+    history: subjectDrawHistory,
     held: async (accountId, kind, subject) => (await manager()).diagramHeld(accountId, kind, subject),
     ticketsForPr: async (accountId, prId) => (await getTicketSource().ticketsForPr(accountId, prId)).map((t) => ({ ident: t.ident, key: t.ticket.key ?? null })),
     storyMembers: async (ctx, accountId, ident) => (await manager()).liveStoryMembers(ctx, accountId, ident),
@@ -46,6 +56,7 @@ const defaultDeps = {
         await markDiagramRefused(ctx, a.accountId, id, 'no_code');
     },
     dailyCap: config.sequenceDiagramDailyCap,
+    subjectCap: SEQUENCE_DIAGRAM_SUBJECT_DAILY_DRAWS,
     // The ONE agentic switch (config.aiEnabled); the routes and the manager check it too.
     enabled: config.aiEnabled,
 };
@@ -67,6 +78,85 @@ function fold(codes) {
         return 'unknown';
     return 'no';
 }
+// ---- why a design was not redrawn (show the wait) ----
+// `${accountId}|${kind}|${subject}` → the skip and the fingerprint it was skipped at. The slot reads it
+// only while that fingerprint is still the live one (routes.ts `slotFor`), so a later draw or a new
+// head clears it by itself. In memory: a restart forgets it, and the next review asks again.
+const autoSkips = new Map();
+const skipKey = (accountId, kind, subject) => `${accountId}|${kind}|${subject}`;
+function noteSkip(accountId, kind, subject, fp, outcome) {
+    const k = skipKey(accountId, kind, subject);
+    if (outcome === 'daily_cap')
+        autoSkips.set(k, { skip: 'daily_limit', fingerprint: fp });
+    else if (outcome === 'redraw_limit')
+        autoSkips.set(k, { skip: 'redraw_limit', fingerprint: fp });
+    else if (outcome === 'queued' || outcome === 'drawn')
+        autoSkips.delete(k);
+}
+/** Why the last finished review did not draw this subject at `liveFp`; null when it did, or nothing is known. */
+export function diagramAutoSkip(accountId, kind, subject, liveFp) {
+    const s = autoSkips.get(skipKey(accountId, kind, subject));
+    return s != null && liveFp != null && s.fingerprint === liveFp ? s.skip : null;
+}
+export function _resetDiagramSkipsForTest() {
+    autoSkips.clear();
+}
+/** The redraw rule's input for one subject: null for a FIRST draw (never drawn, or a story whose
+ *  pull requests changed since its last design). */
+async function redrawOf(ctx, deps, accountId, kind, subject, dayStartMs, memberIds) {
+    const h = await deps.history(ctx, accountId, kind, subject, dayStartMs);
+    if (!h.drawnBefore)
+        return null;
+    if (memberIds != null) {
+        const before = new Set(h.lastMemberIds ?? []);
+        const same = h.lastMemberIds != null && before.size === memberIds.length && memberIds.every((id) => before.has(id));
+        if (!same)
+            return null;
+    }
+    return { subjectDrawsToday: h.drawsToday, subjectCap: deps.subjectCap };
+}
+/** One ticket's story design, after a review of one of its PRs or after its ticket review. */
+async function drawStory(ctx, deps, accountId, t, used, dayStartMs) {
+    const members = await deps.storyMembers(ctx, accountId, t.ident);
+    const stats = await deps.fileStats(ctx, accountId, members.map((m) => m.prId));
+    const code = fold(members.map((m) => (stats.has(m.prId) ? storedCodeAnswer(stats.get(m.prId)) : 'unknown')));
+    const fp = storyDiagramFingerprint(t.ident, members);
+    const drawn = members.length >= 2 && (await deps.exists(ctx, accountId, 'story', t.ident, fp));
+    const storyArgs = {
+        accountId,
+        kind: 'story',
+        subject: t.ident,
+        prId: null,
+        ticketKey: t.key,
+        fingerprint: fp,
+        headSha: null,
+        members: toDiagramMembers(members),
+        trigger: 'review',
+    };
+    const redraw = members.length >= 2 && !drawn
+        ? await redrawOf(ctx, deps, accountId, 'story', t.ident, dayStartMs, members.map((m) => m.prId))
+        : null;
+    const skip = diagramSkipReason({
+        code,
+        drawnAtFingerprint: drawn,
+        inFlight: await deps.held(accountId, 'story', t.ident),
+        usedToday: used.n,
+        dailyCap: deps.dailyCap,
+        memberCount: members.length,
+        redraw,
+    });
+    if (skip != null) {
+        noteSkip(accountId, 'story', t.ident, fp, skip);
+        if (skip === 'no_code' && !drawn)
+            await deps.refuseNoCode(ctx, storyArgs);
+        return skip;
+    }
+    const r = await deps.enqueue(ctx, storyArgs);
+    noteSkip(accountId, 'story', t.ident, fp, r.outcome);
+    if (r.outcome === 'queued')
+        used.n += 1;
+    return r.outcome;
+}
 /** Never throws. Manual and auto reviews both draw; `reviewTrigger` decides only whether the Claude
  *  spend budget is asked (auto only). */
 export async function maybeDrawDiagramsAfterReview(ctx, a, deps = defaultDeps, nowMs = Date.now()) {
@@ -91,7 +181,8 @@ export async function maybeDrawDiagramsAfterReview(ctx, a, deps = defaultDeps, n
             result.pr = 'no_head';
             return result;
         }
-        let used = await deps.usedToday(ctx, accountId, utcDayStartMs(nowMs));
+        const dayStartMs = utcDayStartMs(nowMs);
+        const used = { n: await deps.usedToday(ctx, accountId, dayStartMs) };
         // ---- the PR's own diagram ----
         const prSubject = String(prId);
         const prFp = prDiagramFingerprint(prId, pr.headSha);
@@ -111,19 +202,22 @@ export async function maybeDrawDiagramsAfterReview(ctx, a, deps = defaultDeps, n
             code: storedCodeAnswer(pr),
             drawnAtFingerprint: prDrawn,
             inFlight: await deps.held(accountId, 'pr', prSubject),
-            usedToday: used,
+            usedToday: used.n,
             dailyCap: deps.dailyCap,
+            redraw: prDrawn ? null : await redrawOf(ctx, deps, accountId, 'pr', prSubject, dayStartMs, null),
         });
         if (prSkip != null) {
             result.pr = prSkip;
+            noteSkip(accountId, 'pr', prSubject, prFp, prSkip);
             if (prSkip === 'no_code' && !prDrawn)
                 await deps.refuseNoCode(ctx, prArgs);
         }
         else {
             const r = await deps.enqueue(ctx, prArgs);
             result.pr = r.outcome;
+            noteSkip(accountId, 'pr', prSubject, prFp, r.outcome);
             if (r.outcome === 'queued')
-                used += 1;
+                used.n += 1;
         }
         // ---- the story diagrams of its tickets ----
         const tickets = (await deps.ticketsForPr(accountId, prId).catch(() => []))
@@ -133,40 +227,7 @@ export async function maybeDrawDiagramsAfterReview(ctx, a, deps = defaultDeps, n
         })
             .slice(0, MAX_TICKETS);
         for (const t of tickets) {
-            const members = await deps.storyMembers(ctx, accountId, t.ident);
-            const stats = await deps.fileStats(ctx, accountId, members.map((m) => m.prId));
-            const code = fold(members.map((m) => (stats.has(m.prId) ? storedCodeAnswer(stats.get(m.prId)) : 'unknown')));
-            const fp = storyDiagramFingerprint(t.ident, members);
-            const drawn = members.length >= 2 && (await deps.exists(ctx, accountId, 'story', t.ident, fp));
-            const storyArgs = {
-                accountId,
-                kind: 'story',
-                subject: t.ident,
-                prId: null,
-                ticketKey: t.key,
-                fingerprint: fp,
-                headSha: null,
-                members: toDiagramMembers(members),
-                trigger: 'review',
-            };
-            const skip = diagramSkipReason({
-                code,
-                drawnAtFingerprint: drawn,
-                inFlight: await deps.held(accountId, 'story', t.ident),
-                usedToday: used,
-                dailyCap: deps.dailyCap,
-                memberCount: members.length,
-            });
-            if (skip != null) {
-                result.stories.push({ ident: t.ident, outcome: skip });
-                if (skip === 'no_code' && !drawn)
-                    await deps.refuseNoCode(ctx, storyArgs);
-                continue;
-            }
-            const r = await deps.enqueue(ctx, storyArgs);
-            result.stories.push({ ident: t.ident, outcome: r.outcome });
-            if (r.outcome === 'queued')
-                used += 1;
+            result.stories.push({ ident: t.ident, outcome: await drawStory(ctx, deps, accountId, t, used, dayStartMs) });
         }
         return result;
     }
@@ -175,4 +236,40 @@ export async function maybeDrawDiagramsAfterReview(ctx, a, deps = defaultDeps, n
         return result;
     }
 }
+/**
+ * Never throws. A TICKET REVIEW of a tracker ticket just succeeded: draw its story design under the
+ * same rules. It closes a race the PR trigger cannot: a PR's ticket link is read when the PR is
+ * received, and can land AFTER that PR's review ended — then the PR review saw a one-PR ticket and
+ * drew no story. A ticket review runs once the link exists (a PR joining is what re-runs it).
+ * `viaPrId` is any member, for the workspace switch.
+ */
+export async function maybeDrawStoryDiagramAfterTicketReview(ctx, a, deps = defaultDeps, nowMs = Date.now()) {
+    if (!deps.enabled)
+        return 'disabled';
+    const p = parseTicketIdent(a.ident);
+    if (p == null || p.kind === 'manual')
+        return 'disabled';
+    try {
+        if (!(await deps.switchedOn(ctx, a.accountId, a.viaPrId)))
+            return 'switched_off';
+        if (a.reviewTrigger === 'auto' && !(await automaticRunAllowed(ctx, a.accountId, 'diagrams')))
+            return 'over_budget';
+        const dayStartMs = utcDayStartMs(nowMs);
+        const used = { n: await deps.usedToday(ctx, a.accountId, dayStartMs) };
+        return await drawStory(ctx, deps, a.accountId, { ident: a.ident, key: a.ticketKey }, used, dayStartMs);
+    }
+    catch (err) {
+        ctx.log.warn(`story design after the ticket review of ${a.ident}: ${err instanceof Error ? err.message : String(err)}`);
+        return 'disabled';
+    }
+}
+/** One log line when a finished review drew nothing because of a limit (silent otherwise). */
+export function logTriggerLimits(ctx, prId, r) {
+    const limited = [
+        r.pr === 'daily_cap' || r.pr === 'redraw_limit' ? `pr ${prId}: ${r.pr}` : null,
+        ...r.stories.filter((s) => s.outcome === 'daily_cap' || s.outcome === 'redraw_limit').map((s) => `${s.ident}: ${s.outcome}`),
+    ].filter((x) => x != null);
+    if (limited.length > 0)
+        ctx.log.info(`sequence diagrams not drawn (${limited.join(', ')})`);
+}
 //# sourceMappingURL=trigger.js.map

package/dist/review/ticket-review/manager.js

@@ -181,6 +181,24 @@ function launch(job) {
     progress({ phase: 'preparing' });
     void runPipeline(job, controller, progress)
         .then(() => {
+        // THE STORY DESIGN (review/diagrams/trigger.ts): a SUCCEEDED run of a ticket with 2+ PRs asks
+        // for its story design under the trigger's own rules — a PR's ticket link can land after that
+        // PR's review ended, so the PR review alone can miss it. Fire-and-forget; it only queues.
+        void getTicketReviewById(ctx, job.accountId, runId)
+            .then(async (r) => {
+            const via = r?.members[0]?.prId;
+            if (r?.status !== 'succeeded' || r.members.length < 2 || via == null)
+                return;
+            const m = await import('../diagrams/trigger.js');
+            await m.maybeDrawStoryDiagramAfterTicketReview(ctx, {
+                accountId: job.accountId,
+                ident: job.ident,
+                ticketKey: r.ticketKey,
+                viaPrId: via,
+                reviewTrigger: isAuto(job) ? 'auto' : 'manual',
+            });
+        })
+            .catch((err) => ctx.log.warn(`story design after ticket review ${runId}: ${err instanceof Error ? err.message : String(err)}`));
         // AUTO-POSTING: an AUTOMATIC run that succeeded may post its story gaps on their owner PRs
         // (./auto-post.ts decides, reads the run's status itself, never throws, never retries).
         if (!isAuto(job))

package/dist/review/ticket-review/persist.js

@@ -550,11 +550,21 @@ export async function getTicketStateInputs(ctx, accountId, idents) {
         latestRowsByIdent(ctx, accountId, idents, ['queued', 'running']),
         latestRowsByIdent(ctx, accountId, idents, null),
     ]);
-    const memberRows = await readMembers(ctx, accountId, [...succeeded.values()].map((r) => r.id));
+    // A newer attempt than the latest success (it failed, was refused or was cancelled) reads its own
+    // members too.
+    const newerAttempts = [...any.values()].filter((a) => a.id > (succeeded.get(a.ticketIdent)?.id ?? 0));
+    const memberRows = await readMembers(ctx, accountId, [
+        ...[...succeeded.values()].map((r) => r.id),
+        ...newerAttempts.map((r) => r.id),
+    ]);
+    const membersOf = (runId) => memberRows
+        .filter((m) => m.ticketReviewId === runId)
+        .map((m) => ({ prId: m.prId, headSha: m.headSha, state: m.prState }));
     for (const ident of new Set(idents)) {
         const s = succeeded.get(ident);
         const run = live.get(ident);
         const a = any.get(ident);
+        const newer = a != null && a.id > (s?.id ?? 0);
         out.set(ident, {
             latest: s != null
                 ? {
@@ -564,13 +574,19 @@ export async function getTicketStateInputs(ctx, accountId, idents) {
                     alignment: asAlignment(s.alignment),
                     assessment: s.assessment ?? null,
                     completedAt: asDate(s.completedAt),
-                    members: memberRows
-                        .filter((m) => m.ticketReviewId === s.id)
-                        .map((m) => ({ prId: m.prId, headSha: m.headSha, state: m.prState })),
+                    members: membersOf(s.id),
                 }
                 : null,
             runningRunId: run?.id ?? null,
-            latestAttempt: a != null ? { id: a.id, status: a.status, fingerprint: a.fingerprint, refused: a.refused } : null,
+            latestAttempt: a != null
+                ? {
+                    id: a.id,
+                    status: a.status,
+                    fingerprint: a.fingerprint,
+                    refused: a.refused,
+                    ...(newer ? { ticketHash: a.ticketHash, members: membersOf(a.id) } : {}),
+                }
+                : null,
         });
     }
     return out;
@@ -619,6 +635,19 @@ export async function getTicketItemPostContext(ctx, accountId, runId, itemId) {
     const item = run.items.find((i) => i.id === itemId);
     return item != null ? { run, item } : null;
 }
+/**
+ * The ticket's 'cascade' runs (automatic re-checks) since `dayStartMs` — the per-ticket limit on
+ * re-checks that only follow pushes (sweep.ts). Every workspace counts: it is the ticket's own budget.
+ */
+export async function countCascadeTicketReviewsSince(ctx, accountId, ident, dayStartMs) {
+    const { tr } = tables(ctx);
+    const rows = (await ctx.db
+        .select({ id: tr.id })
+        .from(tr)
+        .where(and(eq(tr.accountId, accountId), eq(tr.ticketIdent, ident), eq(tr.trigger, 'cascade'), gte(tr.createdAt, new Date(dayStartMs))))
+        .execute());
+    return rows.length;
+}
 /**
  * Automatic ticket reviews (trigger 'auto' or 'cascade') a workspace started since `dayStartMs` —
  * the TICKET_REVIEW_DAILY_CAP counter. Manual runs never count.