ensemble-review 1.0.36 → 1.0.38

package/dist/api/plugins/rate-limit.js

@@ -471,6 +471,26 @@ function tierFor(method, path) {
     // GET /api/ticket-prs — the ticket tab: stored ticket rows joined to PRs, DB-only.
     if (!mutating && path === '/api/ticket-prs')
         return [TIERS.read];
+    // GET /api/releases — This Sprint → Releases: the release check over stored tags, ranges and ticket
+    // rows (db/release-check.ts). DB only, never a GitHub or tracker call. `read`, DECIDED; EXACT `===`
+    // (the release WRITES will be their own paths with their own tiers).
+    if (!mutating && path === '/api/releases')
+        return [TIERS.read];
+    // GET /api/releases/:id — one stored release (its notes and step results). DB only.
+    if (!mutating && /^\/api\/releases\/\d+$/.test(path))
+        return [TIERS.read];
+    // POST /api/releases/refresh — Refresh: re-reads the held tickets from the tracker (the customer's
+    // quota, as every tracker call → `search`). No GitHub call.
+    if (method === 'POST' && path === '/api/releases/refresh')
+        return [TIERS.search];
+    // POST /api/releases/preview — the "Create release…" dialog: a model summary per story when AI is on
+    // (model dollars, the reader's click) → `ai` + `ai_hourly`; no GitHub or tracker call.
+    if (method === 'POST' && path === '/api/releases/preview')
+        return [TIERS.ai, TIERS.aiHourly];
+    // POST /api/releases — Confirm: re-reads every ticket from the tracker (the customer's quota, as every
+    // tracker call → `search`) and writes release tags, pre-releases and tracker comments (`github_write`).
+    if (method === 'POST' && path === '/api/releases')
+        return [TIERS.search, TIERS.githubWrite];
     // A TRACKER WRITE (tracker/status-change.ts): GET /api/ticket-status/transitions (one or two
     // Jira calls, on the picker's open) and POST /api/ticket-status (the transition + its re-read) both
     // spend the customer's Jira quota with the saved token → `search`, as every other tracker call.
@@ -602,6 +622,8 @@ function tierFor(method, path) {
     //   GET list / :id / stream / diff / repos/:repoId/diff / prs/:prId/diff / plan · POST interrupt /
     //   network/allow / discard / plan/decisions / auto-push → read
     //   (auto-push only stores the reader's opt-in; the push it arms runs once, on the host, after a build turn)
+    //   (a HOTFIX build's push is the same route: the hotfix branch, two PRs and one PR-body edit → github_write)
+    //   GET /api/story-builds/hotfix-bases → read (DB only: the synced tags)
     //   POST …/:id/auto-approve · …/:id/ticket-review · GET /api/story-builds/active → read (DB only: the
     //   automatic approval's build turn is started by the plan turn's end and asks the spend gate itself)
     //   POST …/:id/loop/continue   THE REVIEW LOOP's Continue: may start reviews, a fix turn AND pushes

package/dist/api/routes/releases.js

@@ -0,0 +1,181 @@
+import { RELEASE_NOTES_SECTION_MAX, RELEASE_SUFFIX_MAX, validateReleaseSettings, } from '../../shared/index.js';
+import { ReleaseRequestError, createRelease, getReleaseDetail, previewRelease } from '../../releases/create.js';
+import { getReleases } from '../../db/release-check.js';
+import { refreshReleases } from '../../releases/refresh.js';
+import { getReleaseSettingsResponse, setReleaseSettings } from '../../db/release-settings.js';
+import { accountIdOf } from '../plugins/auth.js';
+// RELEASES (docs/RELEASES.md; docs/API.md § Releases). CORE, always registered.
+//
+//   GET /api/workspaces/:id/release-settings   the workspace's release + hotfix suffixes (null = not
+//                                              set; there is no default), `configured` (both set) and
+//                                              `hasReleases` (the form warns before a change).
+//   PUT /api/workspaces/:id/release-settings   the WHOLE setting: `{ releaseSuffix, hotfixSuffix }`,
+//                                              null or "" clears one. 400 with the SAME sentence
+//                                              shared `validateReleaseSettings` gives the Settings form.
+//   GET /api/releases?workspace=<id>           This Sprint → Releases: the release check (shared
+//                                              `foldReleaseCheck` over db/release-check.ts's stored
+//                                              inputs), the newest release, whether both suffixes are
+//                                              set. DB only, NEVER a GitHub or tracker call; tier `read`.
+//   POST /api/releases/refresh?workspace=<id>  Refresh (a reader's press): the tickets the check holds by
+//                                              their own state read again from the tracker
+//                                              (releases/refresh.ts), then the check. Tier `search`.
+//   POST /api/releases/preview?workspace=<id>  "Create release…" opening: `{repoIds}` → the snapshot,
+//                                              the notes (a model summary per story when AI is on — a
+//                                              reader's click, never refused by the spend gate) and the
+//                                              comment preview. No GitHub or tracker call; tier `ai`.
+//   POST /api/releases?workspace=<id>          Confirm: `{repoIds, snapshot, sections?}` → re-reads the
+//                                              tickets and the tags, then the writes (releases/create.ts).
+//                                              Tracker reads + GitHub writes: tier `search` + `github_write`.
+//   GET  /api/releases/:id                     one stored release (its notes and per-step results).
+//
+// Both are DB only — the workspace-CRUD `read` tier (api/plugins/rate-limit.ts). 404 on a workspace
+// that is not this account's, like every id-addressed workspace route.
+const idParamSchema = {
+    type: 'object',
+    required: ['id'],
+    properties: { id: { type: 'integer' } },
+};
+const suffixSchema = { type: ['string', 'null'], maxLength: RELEASE_SUFFIX_MAX * 4 };
+const repoIdsSchema = { type: 'array', minItems: 1, maxItems: 200, items: { type: 'integer' } };
+const snapshotSchema = {
+    type: 'object',
+    required: ['repos', 'tickets'],
+    additionalProperties: false,
+    properties: {
+        repos: {
+            type: 'array',
+            maxItems: 200,
+            items: {
+                type: 'object',
+                required: ['repoId', 'tagName', 'sha'],
+                additionalProperties: false,
+                properties: {
+                    repoId: { type: 'integer' },
+                    tagName: { type: 'string', minLength: 1, maxLength: 300 },
+                    sha: { type: 'string', minLength: 1, maxLength: 64 },
+                },
+            },
+        },
+        tickets: {
+            type: 'array',
+            maxItems: 2000,
+            items: {
+                type: 'object',
+                required: ['ident', 'key'],
+                additionalProperties: false,
+                properties: { ident: { type: 'string', minLength: 1, maxLength: 600 }, key: { type: 'string', minLength: 1, maxLength: 200 } },
+            },
+        },
+    },
+};
+export async function releaseRoutes(app) {
+    app.get('/api/releases', async (req) => {
+        const q = req.query;
+        return getReleases(accountIdOf(req), q.workspace);
+    });
+    const refusal = (reply, err) => {
+        if (err instanceof ReleaseRequestError) {
+            reply.status(err.status);
+            return { error: err.code, message: err.message };
+        }
+        throw err;
+    };
+    app.post('/api/releases/refresh', async (req) => {
+        const q = req.query;
+        return refreshReleases(accountIdOf(req), q.workspace);
+    });
+    app.post('/api/releases/preview', {
+        schema: {
+            body: { type: 'object', required: ['repoIds'], additionalProperties: false, properties: { repoIds: repoIdsSchema } },
+        },
+    }, async (req, reply) => {
+        const q = req.query;
+        try {
+            return await previewRelease(accountIdOf(req), q.workspace, req.body);
+        }
+        catch (err) {
+            return refusal(reply, err);
+        }
+    });
+    app.post('/api/releases', {
+        schema: {
+            body: {
+                type: 'object',
+                required: ['repoIds', 'snapshot'],
+                additionalProperties: false,
+                properties: {
+                    repoIds: repoIdsSchema,
+                    snapshot: snapshotSchema,
+                    sections: {
+                        type: 'array',
+                        maxItems: 200,
+                        items: {
+                            type: 'object',
+                            required: ['repoId', 'markdown'],
+                            additionalProperties: false,
+                            properties: { repoId: { type: 'integer' }, markdown: { type: 'string', maxLength: RELEASE_NOTES_SECTION_MAX } },
+                        },
+                    },
+                },
+            },
+        },
+    }, async (req, reply) => {
+        const q = req.query;
+        try {
+            return await createRelease(accountIdOf(req), q.workspace, req.body);
+        }
+        catch (err) {
+            return refusal(reply, err);
+        }
+    });
+    app.get('/api/releases/:id', { schema: { params: idParamSchema } }, async (req, reply) => {
+        const { id } = req.params;
+        const detail = await getReleaseDetail(accountIdOf(req), id);
+        if (detail == null) {
+            reply.status(404);
+            return { error: 'NotFound', message: `Release ${id} not found` };
+        }
+        return detail;
+    });
+    app.get('/api/workspaces/:id/release-settings', { schema: { params: idParamSchema } }, async (req, reply) => {
+        const accountId = accountIdOf(req);
+        const { id } = req.params;
+        const res = await getReleaseSettingsResponse(accountId, id);
+        if (!res) {
+            reply.status(404);
+            return { error: 'NotFound', message: `Workspace ${id} not found` };
+        }
+        return res;
+    });
+    app.put('/api/workspaces/:id/release-settings', {
+        schema: {
+            params: idParamSchema,
+            body: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['releaseSuffix', 'hotfixSuffix'],
+                properties: { releaseSuffix: suffixSchema, hotfixSuffix: suffixSchema },
+            },
+        },
+    }, async (req, reply) => {
+        const accountId = accountIdOf(req);
+        const { id } = req.params;
+        const body = req.body;
+        const problem = validateReleaseSettings(body);
+        if (problem) {
+            reply.status(400);
+            return { error: 'InvalidReleaseSettings', message: problem };
+        }
+        if (!(await setReleaseSettings(accountId, id, body))) {
+            reply.status(404);
+            return { error: 'NotFound', message: `Workspace ${id} not found` };
+        }
+        const res = await getReleaseSettingsResponse(accountId, id);
+        if (!res) {
+            reply.status(404);
+            return { error: 'NotFound', message: `Workspace ${id} not found` };
+        }
+        return res;
+    });
+}
+//# sourceMappingURL=releases.js.map

package/dist/app.js

@@ -18,6 +18,7 @@ import { registerTracker } from './tracker/index.js';
 import { registerSonar } from './sonar/index.js';
 import { repoRoutes } from './api/routes/repos.js';
 import { workspaceRoutes } from './api/routes/workspaces.js';
+import { releaseRoutes } from './api/routes/releases.js';
 import { sandboxSettingsRoutes } from './api/routes/sandbox-settings.js';
 import { userRoutes } from './api/routes/users.js';
 import { timelineRoutes } from './api/routes/timeline.js';
@@ -161,6 +162,8 @@ export async function buildApp() {
     // a repo belongs to exactly one — so assignment is a MOVE and there is no "unassign" route.
     // Account-scoped, no AI, no GitHub calls.
     await app.register(workspaceRoutes);
+    // Releases (CORE, docs/RELEASES.md): the per-workspace release + hotfix suffixes. DB only.
+    await app.register(releaseRoutes);
     await app.register(userRoutes);
     await app.register(timelineRoutes);
     await app.register(prRoutes);

package/dist/coding/story-build/base-refs.js

@@ -20,6 +20,11 @@ export const STORY_BUILD_REF_PREFIX = 'refs/pierre/story-build/';
 export function storyBuildBaseRef(buildId, repoId) {
     return `${STORY_BUILD_REF_PREFIX}${buildId}/${repoId}`;
 }
+/** HOTFIX: the ref pinning one repository's MAIN checkout base (the default branch at the build's start). It
+ *  shares the repository's sweep key (`buildId/repoId`), so it is kept and dropped with that base. */
+export function storyBuildMainRef(buildId, repoId) {
+    return `${STORY_BUILD_REF_PREFIX}${buildId}/main/${repoId}`;
+}
 /** The sweep's keep-list spelling of a key: `buildId/repoId` or `buildId/stack/prRowId`. */
 export function storyBuildRefKey(k) {
     return k.stackPrId != null ? `${k.buildId}/stack/${k.stackPrId}` : `${k.buildId}/${k.repoId}`;
@@ -32,6 +37,9 @@ export function parseStoryBuildBaseRef(ref) {
     const stack = /^(\d+)\/stack\/(\d+)$/.exec(rest);
     if (stack != null)
         return { buildId: Number(stack[1]), stackPrId: Number(stack[2]) };
+    const main = /^(\d+)\/main\/(\d+)$/.exec(rest);
+    if (main != null)
+        return { buildId: Number(main[1]), repoId: Number(main[2]) };
     const m = /^(\d+)\/(\d+)$/.exec(rest);
     if (m == null)
         return null;
@@ -58,8 +66,8 @@ export async function dropStoryBuildBaseRefs(fullName, buildId, repoId) {
     if (!existsSync(join(dir, '.git')))
         return;
     await withRepoLock(`${owner}/${name}`, async () => {
-        const prefix = repoId != null ? storyBuildBaseRef(buildId, repoId) : `${STORY_BUILD_REF_PREFIX}${buildId}/`;
-        const refs = (await gitOut(dir, ['for-each-ref', '--format=%(refname)', prefix]).catch(() => ''))
+        const prefixes = repoId != null ? [storyBuildBaseRef(buildId, repoId), storyBuildMainRef(buildId, repoId)] : [`${STORY_BUILD_REF_PREFIX}${buildId}/`];
+        const refs = (await gitOut(dir, ['for-each-ref', '--format=%(refname)', ...prefixes]).catch(() => ''))
             .split('\n')
             .map((l) => l.trim())
             .filter(Boolean);

package/dist/coding/story-build/loop/driver.js

@@ -181,7 +181,7 @@ export async function maybeStartLoop(ctx, input) {
         if (running.has(buildId))
             return 'skipped';
         const b = await getStoryBuildRow(ctx, accountId, buildId);
-        if (!b || !b.autoPush || b.loopClaimedAt != null || b.autoPushClaimedAt != null || b.status !== 'ready')
+        if (!b || !b.autoPush || b.hotfix === true || b.loopClaimedAt != null || b.autoPushClaimedAt != null || b.status !== 'ready')
             return 'skipped';
         const targets = (await loopTargets(ctx, accountId, buildId)).filter(isLive);
         if (targets.length === 0)

package/dist/coding/story-build/loop/routes.js

@@ -1,4 +1,4 @@
-import { STORY_BUILD_API, STORY_BUILD_BRANCH_MAX, STORY_BUILD_LOOP_ROUNDS_MAX, STORY_BUILD_LOOP_ROUNDS_MIN, } from '../../../shared/index.js';
+import { HOTFIX_NO_LOOP_LINE, STORY_BUILD_API, STORY_BUILD_BRANCH_MAX, STORY_BUILD_LOOP_ROUNDS_MAX, STORY_BUILD_LOOP_ROUNDS_MIN, } from '../../../shared/index.js';
 import { getStoryBuildRow } from '../persist.js';
 import { continueLoop, setLoopSettings, stopLoop, storyLoopWire } from './driver.js';
 const NOT_FOUND = { error: 'NotFound', message: 'Not found.' };
@@ -73,6 +73,14 @@ export function registerStoryBuildLoopRoutes(app, ctx) {
         if (!body) {
             return reply.code(400).send({ error: 'BadRequest', message: `Send \`on\` (true or false) and/or \`rounds\` (${STORY_BUILD_LOOP_ROUNDS_MIN} to ${STORY_BUILD_LOOP_ROUNDS_MAX}).` });
         }
+        // A HOTFIX build never runs the review loop (v1; docs/STORY-BUILD.md § Hotfix builds).
+        if (body.on === true) {
+            const row = await getStoryBuildRow(ctx, accountId, id);
+            if (row == null)
+                return reply.code(404).send(NOT_FOUND);
+            if (row.hotfix === true)
+                return reply.code(409).send({ error: 'HotfixNoLoop', message: HOTFIX_NO_LOOP_LINE });
+        }
         const r = await setLoopSettings(ctx, accountId, id, body);
         if (r.status === 'not_found')
             return reply.code(404).send(NOT_FOUND);

package/dist/coding/story-build/persist.js

@@ -1,5 +1,5 @@
 import { and, desc, eq, inArray, asc, notInArray } from 'drizzle-orm';
-import { aiRunProvider, isFlowDiagram, isLegacyDesignDiagram, isStoryBuildOpen, isStoryBuildRunning, storyBuildDocsEffectiveDecisions, } from '../../shared/index.js';
+import { aiRunProvider, hotfixBranchName, hotfixPortOf, isFlowDiagram, isLegacyDesignDiagram, isStoryBuildOpen, isStoryBuildRunning, storyBuildDocsEffectiveDecisions, } from '../../shared/index.js';
 /* eslint-disable @typescript-eslint/no-explicit-any */
 const B = (ctx) => ctx.schema.storyBuilds;
 const R = (ctx) => ctx.schema.storyBuildRepos;
@@ -99,6 +99,7 @@ export async function insertStoryBuild(ctx, a) {
             ...(a.session ? { sessionPhase: 'booting', effort: a.session.effort, lastActiveAt: a.session.lastActiveAt } : {}),
             wantDiagram: a.wantDiagram,
             wantDocs: a.wantDocs,
+            ...(a.hotfix === true ? { hotfix: true } : {}),
             createdAt: new Date(),
             startedAt: new Date(),
         })
@@ -146,13 +147,14 @@ export async function upsertStoryBuildRepo(ctx, a) {
         stackedOnPrId: a.stackedOnPrId,
         branch: a.branch,
     };
+    const hotfix = () => a.hotfix ? { hotfixTag: a.hotfix.tagName, readOnly: a.hotfix.readOnly, mainBaseRef: a.hotfix.mainBaseRef, mainBaseSha: a.hotfix.mainBaseSha } : {};
     const rows = (await ctx.db
         .insert(r)
-        .values(values)
+        .values({ ...values, ...hotfix() })
         .onConflictDoUpdate({
         target: [r.buildId, r.repoId],
         // A separate object from `values` (CLAUDE.md: never share one between insert and `set:`).
-        set: { ref: a.ref, buildOrder: a.buildOrder, include: a.include, status: a.status, baseRef: a.baseRef, baseSha: a.baseSha, stackedOnPrId: a.stackedOnPrId, branch: a.branch },
+        set: { ref: a.ref, buildOrder: a.buildOrder, include: a.include, status: a.status, baseRef: a.baseRef, baseSha: a.baseSha, stackedOnPrId: a.stackedOnPrId, branch: a.branch, ...hotfix() },
     })
         .returning({ id: r.id })
         .execute());
@@ -185,13 +187,55 @@ export async function deleteStoryBuildRepoRowsExcept(ctx, accountId, buildId, ke
         .execute());
     return rows.length;
 }
-/** The stored patch of one repository (the `…/diff` route; never part of `StoryBuild`). */
-export async function getStoryBuildRepoPatch(ctx, accountId, buildId, repoId) {
+/** The stored patch of one repository (the `…/diff` route; never part of `StoryBuild`). `target: 'main'` = a
+ *  hotfix build's MAIN FIX (null on a row without a main checkout). */
+export async function getStoryBuildRepoPatch(ctx, accountId, buildId, repoId, target = 'release') {
     const row = await getStoryBuildRepoRow(ctx, accountId, buildId, repoId);
     if (row == null)
         return null;
+    if (target === 'main') {
+        if (row.mainBaseSha == null)
+            return null;
+        return { baseSha: row.mainBaseSha, patch: row.mainPatch ?? null, filesChanged: row.mainFilesChangedJson ?? [] };
+    }
     return { baseSha: row.baseSha, patch: row.patch ?? null, filesChanged: row.filesChangedJson ?? [] };
 }
+const MAIN_STATUSES = new Set(['ready', 'skipped', 'failed', 'pushed']);
+/** A hotfix build's per-repository facts on the wire (null on an ordinary build). */
+export function toStoryBuildRepoHotfix(row, hotfixBuild) {
+    if (!hotfixBuild)
+        return null;
+    return {
+        tagName: row.hotfixTag ?? null,
+        readOnly: row.readOnly === true,
+        hotfixBranch: row.hotfixTag != null ? hotfixBranchName(row.hotfixTag) : null,
+        mainBaseRef: row.mainBaseRef ?? null,
+        mainBaseSha: row.mainBaseSha ?? null,
+        mainStatus: row.mainStatus != null && MAIN_STATUSES.has(row.mainStatus) ? row.mainStatus : null,
+        mainHasPatch: row.mainPatch != null && row.mainPatch.length > 0,
+        mainFilesChanged: row.mainFilesChangedJson ?? [],
+        mainInsertions: row.mainStatJson?.insertions ?? null,
+        mainDeletions: row.mainStatJson?.deletions ?? null,
+        mainError: row.mainError ?? null,
+        mainPushedBranch: row.mainPushedBranch ?? null,
+        mainPushedPrNumber: row.mainPushedPrNumber ?? null,
+        mainPushedPrUrl: row.mainPushedPrUrl ?? null,
+        mainPushError: row.mainPushError ?? null,
+        mainPushErrorCode: row.mainPushErrorCode ?? null,
+        branch: row.hotfixBranchJson ?? null,
+        // THE PORT REPORT: the agent's claim, checked against the two stored patches (derived on read).
+        port: row.readOnly === true ? null : storyBuildRepoPort(row),
+    };
+}
+/** One hotfix repository's port report (shared `hotfixPortOf` over the stored claim and the two patches). */
+export function storyBuildRepoPort(row) {
+    return hotfixPortOf({
+        claim: row.portReportJson ?? null,
+        releaseFiles: row.patch != null && row.patch.length > 0 ? (row.filesChangedJson ?? []) : [],
+        mainFiles: row.mainPatch != null && row.mainPatch.length > 0 ? (row.mainFilesChangedJson ?? []) : [],
+        mainChanged: row.mainPatch != null && row.mainPatch.length > 0,
+    });
+}
 // ---- the wire mapper --------------------------------------------------------------------------------
 const iso = (d) => d == null ? null : (d instanceof Date ? d : new Date(typeof d === 'number' && d < 1e12 ? d * 1000 : d)).toISOString();
 const sumOrNull = (xs) => {
@@ -199,7 +243,7 @@ const sumOrNull = (xs) => {
     return got.length === 0 ? null : got.reduce((a, b) => a + b, 0);
 };
 /** One repository row → wire. `candidate` supplies the one-line base note; `fullName` the repo's name. */
-export function toStoryBuildRepo(row, fullName, candidate) {
+export function toStoryBuildRepo(row, fullName, candidate, hotfixBuild = false) {
     return {
         id: row.id,
         repoId: row.repoId,
@@ -228,6 +272,7 @@ export function toStoryBuildRepo(row, fullName, candidate) {
         pushedAt: iso(row.pushedAt),
         pushError: row.pushError ?? null,
         pushErrorCode: row.pushErrorCode ?? null,
+        ...(hotfixBuild ? { hotfix: toStoryBuildRepoHotfix(row, true) } : {}),
         ...(row.model != null || row.provider != null ? { provider: aiRunProvider(row.provider, row.model) } : {}),
         model: row.model ?? null,
         effort: row.effort ?? null,
@@ -244,7 +289,7 @@ export function toStoryBuild(row, repoRows, opts) {
     const byRepo = new Map(candidates.map((c) => [c.repoId, c]));
     const repos = [...repoRows]
         .sort((a, b) => a.buildOrder - b.buildOrder || a.id - b.id)
-        .map((r) => toStoryBuildRepo(r, opts.repoNames.get(r.repoId) ?? byRepo.get(r.repoId)?.fullName ?? `#${r.repoId}`, byRepo.get(r.repoId) ?? null));
+        .map((r) => toStoryBuildRepo(r, opts.repoNames.get(r.repoId) ?? byRepo.get(r.repoId)?.fullName ?? `#${r.repoId}`, byRepo.get(r.repoId) ?? null, row.hotfix === true));
     const built = repos.filter((r) => r.include && (r.status === 'ready' || r.status === 'pushed'));
     const running = isStoryBuildRunning(row.status) || row.docsStatus === 'running';
     return {
@@ -289,6 +334,7 @@ export function toStoryBuild(row, repoRows, opts) {
         ticketReviewDoneAt: iso(row.ticketReviewDoneAt),
         endToEnd: row.endToEnd === true,
         endToEndTicket: row.e2eTicketJson ?? null,
+        hotfix: row.hotfix === true,
         createdAt: iso(row.createdAt) ?? new Date(0).toISOString(),
         startedAt: iso(row.startedAt),
         completedAt: iso(row.completedAt),

package/dist/coding/story-build/plan-persist.js

@@ -171,7 +171,7 @@ export async function approvePlanRevision(ctx, a) {
         if (rows.length === 0 || rows[0].approvedPlanId != null)
             return false;
         await db.update(b).set({ approvedPlanId: a.plan.id, approvedAt: a.now }).where(and(eq(b.id, a.buildId), eq(b.accountId, a.accountId))).execute();
-        for (const [position, p] of revision.stack.entries()) {
+        for (const [position, p] of a.writePrs === false ? [] : revision.stack.entries()) {
             await db
                 .insert(pr)
                 .values({