ensemble-review 1.0.35 → 1.0.37

package/dist/db/migrations/meta/_journal.json

@@ -1366,6 +1366,34 @@
       "when": 1793520000000,
       "tag": "0194_story_build_claims",
       "breakpoints": true
+    },
+    {
+      "idx": 195,
+      "version": "6",
+      "when": 1793606400000,
+      "tag": "0195_releases",
+      "breakpoints": true
+    },
+    {
+      "idx": 196,
+      "version": "6",
+      "when": 1793692800000,
+      "tag": "0196_story_build_hotfix",
+      "breakpoints": true
+    },
+    {
+      "idx": 197,
+      "version": "6",
+      "when": 1793779200000,
+      "tag": "0197_release_items_live_tag",
+      "breakpoints": true
+    },
+    {
+      "idx": 198,
+      "version": "6",
+      "when": 1793865600000,
+      "tag": "0198_story_build_port_report",
+      "breakpoints": true
     }
   ]
 }

package/dist/db/queries.js

@@ -491,6 +491,13 @@ export async function deleteWorkspace(id, accountId) {
         // 1b. EXTRA External memberships (migration 0191). The deleted workspace's own rows go (the
         //     FK cascades too); a repo re-homed to Default by step 1 loses any extra row it had THERE,
         //     because a repo is never External in its own home.
+        // RELEASES (migration 0195): the workspace's releases follow its repos to Default — a release is
+        // history of those repos' tags, and the cascade would delete it.
+        await tx
+            .update(schema.releases)
+            .set({ workspaceId: defaultId })
+            .where(and(eq(schema.releases.accountId, accountId), eq(schema.releases.workspaceId, id)))
+            .execute();
         await tx
             .delete(workspaceExternalRepos)
             .where(and(eq(workspaceExternalRepos.accountId, accountId), eq(workspaceExternalRepos.workspaceId, id)))
@@ -8205,6 +8212,20 @@ export async function deleteRepo(id, accountId) {
         // nothing else, but a surviving row would keep this repo's file paths after the repo is gone
         // AND, on Postgres, block the `repos` delete outright.
         await tx.delete(schema.repoFileCoupling).where(eq(schema.repoFileCoupling.repoId, id)).execute();
+        // RELEASES (migration 0195): the repo's tags, their ranges and its release items (the release
+        // rows themselves are the workspace's and stay). Their repo FKs cascade; explicit all the same.
+        await tx
+            .delete(schema.repoTagRanges)
+            .where(and(eq(schema.repoTagRanges.repoId, id), eq(schema.repoTagRanges.accountId, accountId)))
+            .execute();
+        await tx
+            .delete(schema.repoTags)
+            .where(and(eq(schema.repoTags.repoId, id), eq(schema.repoTags.accountId, accountId)))
+            .execute();
+        await tx
+            .delete(schema.releaseItems)
+            .where(and(eq(schema.releaseItems.repoId, id), eq(schema.releaseItems.accountId, accountId)))
+            .execute();
         // Docs folders offered from this repo (migration 0155). The composite FK cascades; explicit
         // anyway, for the same stated reason as the rows above.
         await tx

package/dist/db/release-check.js

@@ -0,0 +1,378 @@
+// THE RELEASE CHECK'S DB HALF (docs/RELEASES.md § The release check) — gathers the stored inputs of
+// shared `foldReleaseCheck` and answers GET /api/releases. DB ONLY: never a GitHub or tracker call.
+//
+//   • Repos: the workspace's members (`resolveWorkspaceScope`), their stored tags and range increments
+//     (db/repo-tags.ts), `writable` from the synced `viewerPermission` (the ONE WRITE_PERMISSIONS set).
+//   • PRs: every PR in a stored range, plus every PR (in the workspace's repos) on a ticket one of them
+//     names — the ships-whole and open-work rules need the ticket's PRs everywhere.
+//   • Tickets: `tracker_tickets` rows ON THE WORKSPACE'S TRACKER SITE only (a row of another site is a
+//     ticket of a tracker the workspace no longer uses: not a link). The best row per ticket is the
+//     newest successful read; a fresher `sprint_tickets` row's status wins. DONE = the This Sprint
+//     stage resolver (`sprintStageOf` over `sprintLayoutFor`) says Complete — never a second resolver.
+//     A range PR with a ticket key THE detection rule finds but no stored row yet is `not_read` (blocks).
+//   • A 'history' range (the oldest tag) is read fresh from the stored PRs, never from its frozen row.
+//   • Bot-ness: `globalAutomationUserIds`, never the hidden-bots list.
+//   • Accepted repos: `sprint_ticket_repos` (the reader's accepted repos per ticket).
+import { and, desc, eq, inArray, isNotNull, lte, or } from 'drizzle-orm';
+import { foldReleaseCheck, releaseSettingsConfigured, tagKind, trackerTicketIdent, } from '../shared/index.js';
+import { globalAutomationUserIds } from './automation-ids.js';
+import { db, schema } from './client.js';
+import { WRITE_PERMISSIONS, resolveWorkspaceScope } from './queries.js';
+import { getReleaseSettings } from './release-settings.js';
+import { getRepoTags, getTagRanges } from './repo-tags.js';
+import { sprintLayoutFor, sprintStageOf } from './sprint-status-layout.js';
+const { repos, pullRequests, trackerTickets, sprintTickets, sprintTicketRepos, releases } = schema;
+const CHUNK = 400;
+function chunks(xs, n = CHUNK) {
+    const out = [];
+    for (let i = 0; i < xs.length; i += n)
+        out.push(xs.slice(i, i + n));
+    return out;
+}
+/** Done = the workspace's Complete stage, through THE This Sprint stage resolver. With no stored
+ *  layout (the sprint was never read) the resolver's category fallback decides (`done` → Complete,
+ *  so "Won't do" counts). Pure. */
+export function ticketIsDone(layout, statusName, statusCategory) {
+    if (statusName == null && statusCategory == null)
+        return false;
+    return sprintStageOf(layout ?? { order: [] }, { name: statusName ?? '', category: statusCategory }) === 'done';
+}
+const READ_STATES = new Set(['ok', 'not_found', 'no_access', 'failed']);
+/** The ticket from its rows (one per PR): the newest successful read, else the newest attempt. Pure. */
+export function bestTicketRow(rows) {
+    const ms = (d) => (d == null ? 0 : d.getTime());
+    const ok = rows.filter((r) => r.state === 'ok' && r.fetchedAt != null).sort((a, b) => ms(b.fetchedAt) - ms(a.fetchedAt));
+    if (ok[0] != null)
+        return ok[0];
+    return [...rows].sort((a, b) => ms(b.checkedAt) - ms(a.checkedAt))[0] ?? null;
+}
+/**
+ * THE ONE detection rule (tracker/enricher.ts `detectKeysWithAccess`: title + head branch + stored
+ * links) over these PRs, against the WORKSPACE's tracker: prId → keys. DB only (no tracker call). A
+ * key detected on a range PR with no stored row is a ticket the worker has not read yet — it BLOCKS
+ * (`not_read`), never passes as an untracked PR.
+ */
+async function detectedKeysByPr(accountId, workspaceId, prIds) {
+    const out = new Map();
+    if (prIds.length === 0)
+        return out;
+    // LAZY: tracker/runtime.ts opens the database at import.
+    const [{ trackerContext }, { readWorkspaceTrackerRow, trackerAccessOf }, { detectKeysWithAccess, withParsedLinks, prLinkColumns }] = await Promise.all([import('../tracker/runtime.js'), import('../tracker/settings.js'), import('../tracker/enricher.js')]);
+    const ctx = trackerContext();
+    const access = trackerAccessOf(ctx.host, await readWorkspaceTrackerRow(ctx, accountId, workspaceId));
+    for (const part of chunks(prIds)) {
+        const rows = await db
+            .select({ id: pullRequests.id, title: pullRequests.title, headRefName: pullRequests.headRefName, ...prLinkColumns(pullRequests) })
+            .from(pullRequests)
+            .where(and(eq(pullRequests.accountId, accountId), inArray(pullRequests.id, part)))
+            .execute();
+        for (const r of rows) {
+            const keys = detectKeysWithAccess(access, withParsedLinks(r));
+            if (keys != null && keys.length > 0)
+                out.set(r.id, keys);
+        }
+    }
+    return out;
+}
+/**
+ * A 'history' range (the oldest tag: no base) is read FRESH from the stored PRs, never from its frozen
+ * row: PRs the deep backfill brings in after the row was computed must enter it. Merged into the
+ * default branch no later than the tag's commit (or by the tag's own commit). prIds per tag name.
+ */
+async function historyPrIds(accountId, repoId, defaultBranch, tag) {
+    const rows = await db
+        .select({ id: pullRequests.id })
+        .from(pullRequests)
+        .where(and(eq(pullRequests.accountId, accountId), eq(pullRequests.repoId, repoId), eq(pullRequests.state, 'merged'), eq(pullRequests.baseRefName, defaultBranch), or(eq(pullRequests.mergeCommitOid, tag.sha), and(isNotNull(pullRequests.mergedAt), lte(pullRequests.mergedAt, tag.committedAt)))))
+        .execute();
+    return [...new Set(rows.map((r) => r.id))].sort((a, b) => a - b);
+}
+/** Every stored input of the fold for one workspace (the caller checked the settings are set). */
+export async function loadReleaseCheckInput(accountId, workspaceId, repoIds, settings) {
+    const repoRows = repoIds.length === 0
+        ? []
+        : await db
+            .select({
+            id: repos.id,
+            owner: repos.owner,
+            name: repos.name,
+            defaultBranch: repos.defaultBranch,
+            defaultBranchName: repos.defaultBranchName,
+            viewerPermission: repos.viewerPermission,
+        })
+            .from(repos)
+            .where(and(eq(repos.accountId, accountId), inArray(repos.id, [...repoIds])))
+            .execute();
+    const ids = repoRows.map((r) => r.id);
+    const [tags, storedRanges] = await Promise.all([getRepoTags(accountId, ids), getTagRanges(accountId, ids)]);
+    const repoRowById = new Map(repoRows.map((r) => [r.id, r]));
+    const ranges = await Promise.all(storedRanges.map(async (r) => {
+        if (r.method !== 'history')
+            return r;
+        const tag = tags.find((t) => t.repoId === r.repoId && t.name === r.tagName);
+        const row = repoRowById.get(r.repoId);
+        const def = row?.defaultBranch ?? row?.defaultBranchName ?? null;
+        if (tag == null || tag.sha !== r.sha || tag.committedAt == null || def == null)
+            return r;
+        return { ...r, prIds: await historyPrIds(accountId, r.repoId, def, { sha: tag.sha, committedAt: tag.committedAt }), unresolvedPrNumbers: [] };
+    }));
+    // The workspace's tracker site (LAZY: db/stories.ts reaches the tracker runtime).
+    const { workspaceSite } = await import('./stories.js');
+    const site = await workspaceSite(accountId, workspaceId);
+    const rangePrIds = [...new Set(ranges.flatMap((r) => r.prIds))];
+    const ticketRows = [];
+    const detectedOnly = new Map();
+    const ticketSelect = {
+        prId: trackerTickets.prId,
+        issueKey: trackerTickets.issueKey,
+        url: trackerTickets.url,
+        state: trackerTickets.state,
+        title: trackerTickets.title,
+        statusName: trackerTickets.statusName,
+        statusCategory: trackerTickets.statusCategory,
+        fetchedAt: trackerTickets.fetchedAt,
+        checkedAt: trackerTickets.checkedAt,
+    };
+    if (site != null) {
+        for (const part of chunks(rangePrIds)) {
+            ticketRows.push(...(await db
+                .select(ticketSelect)
+                .from(trackerTickets)
+                .where(and(eq(trackerTickets.accountId, accountId), eq(trackerTickets.provider, site.provider), eq(trackerTickets.apiRoot, site.apiRoot), inArray(trackerTickets.prId, part)))
+                .execute()));
+        }
+        // Keys the detection rule finds on a range PR but no stored row answers for that PR yet.
+        const rowKeys = new Map();
+        for (const r of ticketRows)
+            rowKeys.set(r.prId, (rowKeys.get(r.prId) ?? new Set()).add(r.issueKey));
+        for (const [prId, keys] of await detectedKeysByPr(accountId, workspaceId, rangePrIds)) {
+            const missing = keys.filter((k) => !(rowKeys.get(prId)?.has(k) ?? false));
+            if (missing.length > 0)
+                detectedOnly.set(prId, missing);
+        }
+        // Every PR on those tickets (the ticket's other repos, its open work).
+        const keys = [...new Set([...ticketRows.map((r) => r.issueKey), ...[...detectedOnly.values()].flat()])];
+        const have = new Set(ticketRows.map((r) => `${r.prId}#${r.issueKey}`));
+        for (const part of chunks(keys)) {
+            const more = await db
+                .select(ticketSelect)
+                .from(trackerTickets)
+                .where(and(eq(trackerTickets.accountId, accountId), eq(trackerTickets.provider, site.provider), eq(trackerTickets.apiRoot, site.apiRoot), inArray(trackerTickets.issueKey, part)))
+                .execute();
+            for (const r of more)
+                if (!have.has(`${r.prId}#${r.issueKey}`))
+                    ticketRows.push(r);
+        }
+    }
+    // The PRs, within the workspace's repos only.
+    const prIdSet = [...new Set([...rangePrIds, ...ticketRows.map((r) => r.prId)])];
+    const prRows = [];
+    if (ids.length > 0) {
+        for (const part of chunks(prIdSet)) {
+            prRows.push(...(await db
+                .select({
+                id: pullRequests.id,
+                repoId: pullRequests.repoId,
+                number: pullRequests.number,
+                title: pullRequests.title,
+                state: pullRequests.state,
+                baseRefName: pullRequests.baseRefName,
+                mergedAt: pullRequests.mergedAt,
+                authorId: pullRequests.authorId,
+            })
+                .from(pullRequests)
+                .where(and(eq(pullRequests.accountId, accountId), inArray(pullRequests.repoId, ids), inArray(pullRequests.id, part)))
+                .execute()));
+        }
+    }
+    const bots = prRows.some((p) => p.authorId != null) ? await globalAutomationUserIds() : new Set();
+    const identOf = (issueKey) => trackerTicketIdent(site.provider, site.apiRoot, issueKey);
+    const identsByPr = new Map();
+    const rowsByIdent = new Map();
+    for (const r of ticketRows) {
+        const ident = identOf(r.issueKey);
+        const list = identsByPr.get(r.prId) ?? [];
+        if (!list.includes(ident))
+            list.push(ident);
+        identsByPr.set(r.prId, list);
+        rowsByIdent.set(ident, [...(rowsByIdent.get(ident) ?? []), r]);
+    }
+    /** Detected on a range PR, no stored row anywhere on the site: ident → key (read state `not_read`). */
+    const unreadKeys = new Map();
+    for (const [prId, keys] of detectedOnly) {
+        for (const key of keys) {
+            const ident = identOf(key);
+            const list = identsByPr.get(prId) ?? [];
+            if (!list.includes(ident))
+                list.push(ident);
+            identsByPr.set(prId, list);
+            if (!rowsByIdent.has(ident))
+                unreadKeys.set(ident, key);
+        }
+    }
+    const repoById = new Map(repoRows.map((r) => [r.id, r]));
+    const defaultOf = (repoId) => {
+        const r = repoById.get(repoId);
+        return r?.defaultBranch ?? r?.defaultBranchName ?? null;
+    };
+    const prs = prRows.map((p) => {
+        const r = repoById.get(p.repoId);
+        const def = defaultOf(p.repoId);
+        return {
+            id: p.id,
+            repoId: p.repoId,
+            number: p.number,
+            title: p.title,
+            url: `https://github.com/${r.owner}/${r.name}/pull/${p.number}`,
+            isBot: p.authorId != null && bots.has(p.authorId),
+            intoDefaultBranch: def != null && p.baseRefName === def,
+            state: p.state,
+            mergedAt: p.mergedAt,
+            ticketIdents: identsByPr.get(p.id) ?? [],
+        };
+    });
+    // The tickets: best stored read, a fresher sprint read's status wins, Done by the stage resolver.
+    const idents = [...rowsByIdent.keys(), ...unreadKeys.keys()];
+    const sprintByIdent = new Map();
+    const accepted = [];
+    for (const part of chunks(idents)) {
+        const [srows, arows] = await Promise.all([
+            db
+                .select({
+                ident: sprintTickets.ident,
+                statusName: sprintTickets.statusName,
+                statusCategory: sprintTickets.statusCategory,
+                fetchedAt: sprintTickets.fetchedAt,
+                title: sprintTickets.title,
+                url: sprintTickets.url,
+            })
+                .from(sprintTickets)
+                .where(and(eq(sprintTickets.accountId, accountId), eq(sprintTickets.workspaceId, workspaceId), inArray(sprintTickets.ident, part)))
+                .execute(),
+            db
+                .select({ ident: sprintTicketRepos.ident, repoId: sprintTicketRepos.repoId })
+                .from(sprintTicketRepos)
+                .where(and(eq(sprintTicketRepos.accountId, accountId), eq(sprintTicketRepos.workspaceId, workspaceId), inArray(sprintTicketRepos.ident, part)))
+                .execute(),
+        ]);
+        for (const s of srows)
+            sprintByIdent.set(s.ident, s);
+        accepted.push(...arows.filter((a) => repoById.has(a.repoId)));
+    }
+    const layout = idents.length > 0 ? await sprintLayoutFor(accountId, workspaceId) : null;
+    const tickets = idents.map((ident) => {
+        const unreadKey = unreadKeys.get(ident);
+        if (unreadKey != null) {
+            // A sprint read of it is a real read of the ticket; with none, it is not read yet (blocks).
+            const sprint = sprintByIdent.get(ident);
+            if (sprint == null)
+                return { ident, key: unreadKey, title: null, url: null, statusName: null, done: false, readState: 'not_read' };
+            return {
+                ident,
+                key: unreadKey,
+                title: sprint.title,
+                url: sprint.url,
+                statusName: sprint.statusName,
+                done: ticketIsDone(layout, sprint.statusName, sprint.statusCategory),
+                readState: 'ok',
+            };
+        }
+        const rows = rowsByIdent.get(ident);
+        const best = bestTicketRow(rows);
+        const readState = best.state === 'ok' && best.fetchedAt != null
+            ? 'ok'
+            : READ_STATES.has(best.state) && best.state !== 'ok'
+                ? best.state
+                : 'not_read';
+        const sprint = sprintByIdent.get(ident);
+        const useSprint = sprint != null && (best.fetchedAt == null || sprint.fetchedAt.getTime() > best.fetchedAt.getTime());
+        const statusName = useSprint ? sprint.statusName : best.statusName;
+        const statusCategory = useSprint ? sprint.statusCategory : best.statusCategory;
+        return {
+            ident,
+            key: best.issueKey,
+            title: best.title ?? sprint?.title ?? null,
+            url: best.url ?? sprint?.url ?? null,
+            statusName,
+            done: readState === 'ok' && ticketIsDone(layout, statusName, statusCategory),
+            readState,
+        };
+    });
+    const tagsByRepo = new Map();
+    for (const t of tags)
+        tagsByRepo.set(t.repoId, [...(tagsByRepo.get(t.repoId) ?? []), t]);
+    const rangesByRepo = new Map();
+    for (const r of ranges)
+        rangesByRepo.set(r.repoId, [...(rangesByRepo.get(r.repoId) ?? []), r]);
+    return {
+        settings,
+        repos: [...repoRows]
+            .sort((a, b) => a.name.localeCompare(b.name) || a.id - b.id)
+            .map((r) => ({
+            repoId: r.id,
+            fullName: `${r.owner}/${r.name}`,
+            name: r.name,
+            writable: WRITE_PERMISSIONS.has(r.viewerPermission ?? ''),
+            tags: (tagsByRepo.get(r.id) ?? []).map((t) => ({
+                name: t.name,
+                sha: t.sha,
+                committedAt: t.committedAt,
+                taggedAt: t.taggedAt,
+                onDefaultBranch: t.onDefaultBranch,
+                moved: t.movedAt != null,
+            })),
+            ranges: (rangesByRepo.get(r.id) ?? []).map((x) => ({
+                tagName: x.tagName,
+                sha: x.sha,
+                baseTagName: x.baseTagName,
+                baseSha: x.baseSha,
+                method: x.method,
+                prIds: x.prIds,
+                unresolvedPrNumbers: x.unresolvedPrNumbers,
+                unmatchedCommits: x.unmatchedCommits,
+                truncated: x.truncated,
+            })),
+        })),
+        prs,
+        tickets,
+        acceptedRepos: accepted,
+    };
+}
+/** GET /api/releases. `rawWorkspace` absent / unknown / unparseable ⇒ the Default workspace. */
+export async function getReleases(accountId, rawWorkspace) {
+    const scope = await resolveWorkspaceScope(accountId, rawWorkspace);
+    const workspaceId = scope.workspaceId;
+    const settings = (await getReleaseSettings(accountId, workspaceId)) ?? { releaseSuffix: null, hotfixSuffix: null };
+    const latest = (await db
+        .select({ id: releases.id, createdAt: releases.createdAt, state: releases.state })
+        .from(releases)
+        .where(and(eq(releases.accountId, accountId), eq(releases.workspaceId, workspaceId)))
+        .orderBy(desc(releases.createdAt), desc(releases.id))
+        .limit(1)
+        .execute())[0];
+    const base = {
+        workspaceId,
+        configured: releaseSettingsConfigured(settings),
+        releaseSuffix: settings.releaseSuffix,
+        hotfixSuffix: settings.hotfixSuffix,
+        latestRelease: latest != null ? { id: latest.id, createdAt: latest.createdAt.toISOString(), state: latest.state } : null,
+    };
+    if (!base.configured)
+        return { ...base, latestReleaseTagAt: null, check: null };
+    const input = await loadReleaseCheckInput(accountId, workspaceId, scope.repoIds, settings);
+    let latestTagMs = null;
+    for (const r of input.repos) {
+        for (const t of r.tags) {
+            const k = tagKind(t.name, settings);
+            if ((k === 'release' || k === 'hotfix') && t.committedAt != null) {
+                latestTagMs = Math.max(latestTagMs ?? 0, t.committedAt.getTime());
+            }
+        }
+    }
+    return {
+        ...base,
+        latestReleaseTagAt: latestTagMs == null ? null : new Date(latestTagMs).toISOString(),
+        check: foldReleaseCheck(input),
+    };
+}
+//# sourceMappingURL=release-check.js.map

package/dist/db/release-settings.js

@@ -0,0 +1,94 @@
+// RELEASE SETTINGS (docs/RELEASES.md § Terms and settings) — the ONE reader and writer of
+// `workspaces.release_suffix` / `workspaces.hotfix_suffix` (migration 0195). Per workspace, no
+// inheritance, NO default: null until the reader sets one. Callers validate with shared
+// `validateReleaseSettings` first (the route does; the Settings form runs the same function).
+import { and, eq, inArray } from 'drizzle-orm';
+import { normaliseReleaseSuffix, releaseSettingsConfigured, } from '../shared/index.js';
+import { db, schema } from './client.js';
+const { workspaces, workspaceRepos, repoTags, releases } = schema;
+/** The workspace's settings, RAW (null = not set); null when the workspace is not this account's. */
+export async function getReleaseSettings(accountId, workspaceId) {
+    const row = (await db
+        .select({ releaseSuffix: workspaces.releaseSuffix, hotfixSuffix: workspaces.hotfixSuffix })
+        .from(workspaces)
+        .where(and(eq(workspaces.id, workspaceId), eq(workspaces.accountId, accountId)))
+        .limit(1)
+        .execute())[0];
+    if (!row)
+        return null;
+    return {
+        releaseSuffix: normaliseReleaseSuffix(row.releaseSuffix),
+        hotfixSuffix: normaliseReleaseSuffix(row.hotfixSuffix),
+    };
+}
+/** Every workspace's settings of this account that has BOTH suffixes set (the range planner keeps
+ *  every range after the oldest baseline any of them gives). */
+export async function configuredReleaseSettings(accountId) {
+    const rows = await db
+        .select({ releaseSuffix: workspaces.releaseSuffix, hotfixSuffix: workspaces.hotfixSuffix })
+        .from(workspaces)
+        .where(eq(workspaces.accountId, accountId))
+        .execute();
+    return rows
+        .map((r) => ({ releaseSuffix: normaliseReleaseSuffix(r.releaseSuffix), hotfixSuffix: normaliseReleaseSuffix(r.hotfixSuffix) }))
+        .filter(releaseSettingsConfigured);
+}
+/**
+ * Replace both suffixes (an empty string stores NULL). Returns false when the workspace is not this
+ * account's. Does NOT validate — the caller already ran `validateReleaseSettings`.
+ */
+export async function setReleaseSettings(accountId, workspaceId, settings) {
+    const rows = await db
+        .update(workspaces)
+        .set({
+        releaseSuffix: normaliseReleaseSuffix(settings.releaseSuffix),
+        hotfixSuffix: normaliseReleaseSuffix(settings.hotfixSuffix),
+    })
+        .where(and(eq(workspaces.id, workspaceId), eq(workspaces.accountId, accountId)))
+        .returning({ id: workspaces.id })
+        .execute();
+    return rows.length > 0;
+}
+/**
+ * A release already exists for this workspace: a release row, or a stored tag in one of its repos
+ * that ends in the CURRENT release suffix (a team may have tagged by hand before Ensemble). The Settings
+ * form warns before a change. DB only.
+ */
+export async function workspaceHasReleases(accountId, workspaceId, releaseSuffix) {
+    const made = await db
+        .select({ id: releases.id })
+        .from(releases)
+        .where(and(eq(releases.accountId, accountId), eq(releases.workspaceId, workspaceId)))
+        .limit(1)
+        .execute();
+    if (made.length > 0)
+        return true;
+    if (releaseSuffix == null)
+        return false;
+    const repoIds = (await db
+        .select({ repoId: workspaceRepos.repoId })
+        .from(workspaceRepos)
+        .where(and(eq(workspaceRepos.accountId, accountId), eq(workspaceRepos.workspaceId, workspaceId)))
+        .execute()).map((r) => r.repoId);
+    if (repoIds.length === 0)
+        return false;
+    const names = await db
+        .select({ name: repoTags.name })
+        .from(repoTags)
+        .where(and(eq(repoTags.accountId, accountId), inArray(repoTags.repoId, repoIds)))
+        .execute();
+    return names.some((n) => n.name.length > releaseSuffix.length && n.name.endsWith(releaseSuffix));
+}
+/** The wire shape for GET / PUT /api/workspaces/:id/release-settings; null = not this account's. */
+export async function getReleaseSettingsResponse(accountId, workspaceId) {
+    const settings = await getReleaseSettings(accountId, workspaceId);
+    if (!settings)
+        return null;
+    return {
+        workspaceId,
+        ...settings,
+        configured: releaseSettingsConfigured(settings),
+        hasReleases: await workspaceHasReleases(accountId, workspaceId, settings.releaseSuffix),
+    };
+}
+//# sourceMappingURL=release-settings.js.map

package/dist/db/repo-tags.js

@@ -0,0 +1,82 @@
+// RELEASES' READS of the synced tags and tag ranges (docs/RELEASES.md) — DB only, account-scoped.
+// The release check (a pure fold, next to the Releases routes) builds on these two:
+//   getRepoTags(accountId, repoIds)       every stored tag of those repos
+//   getTagRanges(accountId, repoIds)      every stored range increment, PR NUMBERS resolved to local
+//                                         PR ids within (account, repo) — a number not stored yet is
+//                                         kept in `unresolvedPrNumbers`, never dropped.
+// The writers are sync/repo-tags.ts and sync/tag-ranges.ts.
+import { and, eq, inArray } from 'drizzle-orm';
+import { db, schema } from './client.js';
+const { repoTags, repoTagRanges, pullRequests } = schema;
+export async function getRepoTags(accountId, repoIds) {
+    if (repoIds.length === 0)
+        return [];
+    const rows = await db
+        .select({
+        repoId: repoTags.repoId,
+        name: repoTags.name,
+        sha: repoTags.sha,
+        tagObjectOid: repoTags.tagObjectOid,
+        committedAt: repoTags.committedAt,
+        taggedAt: repoTags.taggedAt,
+        onDefaultBranch: repoTags.onDefaultBranch,
+        previousSha: repoTags.previousSha,
+        movedAt: repoTags.movedAt,
+        firstSeenAt: repoTags.firstSeenAt,
+    })
+        .from(repoTags)
+        .where(and(eq(repoTags.accountId, accountId), inArray(repoTags.repoId, [...repoIds])))
+        .execute();
+    return rows.map(({ tagObjectOid, ...r }) => ({ ...r, annotated: tagObjectOid != null }));
+}
+export async function getTagRanges(accountId, repoIds) {
+    if (repoIds.length === 0)
+        return [];
+    const rows = await db
+        .select()
+        .from(repoTagRanges)
+        .where(and(eq(repoTagRanges.accountId, accountId), inArray(repoTagRanges.repoId, [...repoIds])))
+        .execute();
+    if (rows.length === 0)
+        return [];
+    // number → id, per repo. ONE read of the repos' PR numbers (indexed on account, repo, number).
+    const wanted = [...new Set(rows.flatMap((r) => r.prNumbers ?? []))];
+    const idByKey = new Map();
+    for (let i = 0; i < wanted.length; i += 400) {
+        const part = wanted.slice(i, i + 400);
+        const prs = await db
+            .select({ id: pullRequests.id, repoId: pullRequests.repoId, number: pullRequests.number })
+            .from(pullRequests)
+            .where(and(eq(pullRequests.accountId, accountId), inArray(pullRequests.repoId, [...repoIds]), inArray(pullRequests.number, part)))
+            .execute();
+        for (const p of prs)
+            idByKey.set(`${p.repoId}#${p.number}`, p.id);
+    }
+    return rows.map((r) => {
+        const prIds = [];
+        const unresolvedPrNumbers = [];
+        for (const n of r.prNumbers ?? []) {
+            const id = idByKey.get(`${r.repoId}#${n}`);
+            if (id != null)
+                prIds.push(id);
+            else
+                unresolvedPrNumbers.push(n);
+        }
+        return {
+            repoId: r.repoId,
+            tagName: r.tagName,
+            sha: r.sha,
+            baseTagName: r.baseTagName,
+            baseSha: r.baseSha,
+            method: r.method,
+            prIds,
+            unresolvedPrNumbers,
+            commitCount: r.commitCount,
+            unmatchedCommits: r.unmatchedCommits,
+            truncated: r.truncated,
+            movedFromSha: r.movedFromSha,
+            computedAt: r.computedAt,
+        };
+    });
+}
+//# sourceMappingURL=repo-tags.js.map