ensemble-review 1.0.35 → 1.0.37

package/dist/coding/story-build/push-hotfix.js

@@ -0,0 +1,293 @@
+import { hotfixBranchState, hotfixPairLine, hotfixPortBodyLine, hotfixPushTargets, } from '../../shared/index.js';
+import { sessionBranch } from '../../sandbox/workspace/seed.js';
+import { dropSessionBaseRefs } from './base-refs.js';
+import { getStoryBuildRepoRow, getStoryBuildRow, listStoryBuildRepoRows, storyBuildRepoNames, storyBuildRepoPort, updateStoryBuildRepo, } from './persist.js';
+import { closesFor, coveredBy, defangGithubText, linkTicket, repoFacts, storyBuildPrBody, storyBuildPrTitle } from './push.js';
+// PUSH ONE REPOSITORY OF A HOTFIX BUILD (docs/STORY-BUILD.md § Hotfix builds; docs/RELEASES.md § Hotfix). The
+// reader's press. Every write is the READER'S (origin 'reader': no ledger, no trailer), exactly as Push:
+//
+//   1. `hotfix/<latest release tag>` — read live; made at the release commit when missing (a NEW ref, never
+//      moved). When it has MOVED past the release commit, PR 1 still targets it, and the open PRs already on
+//      it are recorded for the tab.
+//   2. PR 1  `<KEY>` → `hotfix/<tag>`: the RELEASE FIX (the row's patch, on the release commit).
+//   3. PR 2  `<KEY>-main` → the default branch: the MAIN FIX (`main_patch`, on the default branch's base).
+//   4. PR 1's body edited ONCE to link PR 2 (PR 2's body links PR 1 from the start).
+//
+// Both titled `<KEY>: <title>`, draft by default (the toggle), `BRANCH_EXISTS` refused, push permission
+// re-checked. A second press pushes only what is left; once both PRs are open nothing more is written.
+// PR 2 opens only when the main fix changed something: a port report of `not_needed` with an unchanged main
+// checkout opens PR 1 alone. Both bodies carry the port report's one line (shared `hotfixPortBodyLine`) —
+// never when the patches contradict the claim (the tab shows that flag; Push stays the reader's call).
+const pushing = new Set();
+/** A hotfix push of this repository row is in flight. */
+export function isHotfixRepoPushing(repoRowId) {
+    return pushing.has(repoRowId);
+}
+export const defaultHotfixPushDeps = {
+    async canPush(ctx, accountId, repoId) {
+        const { getViewerCanPush } = await import('../ai-fix/pr-context.js');
+        return getViewerCanPush(ctx, accountId, repoId);
+    },
+    async token(accountId) {
+        const { getAccessToken } = await import('../../auth/account.js');
+        return getAccessToken(accountId);
+    },
+    async branchSha(token, owner, name, branch) {
+        const { fetchBranchHeadSha } = await import('../../github/mutations.js');
+        return fetchBranchHeadSha(token, owner, name, branch);
+    },
+    async createBranch(token, a) {
+        const { createHotfixBranch } = await import('../../github/mutations.js');
+        return createHotfixBranch(token, a, 'reader');
+    },
+    async openPrsOnBase(token, owner, name, branch) {
+        const { fetchOpenPrsOnBase } = await import('../../github/mutations.js');
+        return fetchOpenPrsOnBase(token, owner, name, branch);
+    },
+    async pushAndOpen(a) {
+        const { applyAndPushBranch } = await import('../git-ops.js');
+        return applyAndPushBranch(a);
+    },
+    async updateBody(token, owner, name, number, body) {
+        const { updatePullRequestBody } = await import('../../github/mutations.js');
+        const r = await updatePullRequestBody(token, owner, name, number, body, 'reader');
+        return r.ok ? { ok: true } : { ok: false, message: r.message };
+    },
+    now: () => new Date(),
+};
+let deps = defaultHotfixPushDeps;
+/** Test seam (null restores the real steps). */
+export function setHotfixPushDepsForTests(d) {
+    deps = d == null ? defaultHotfixPushDeps : { ...defaultHotfixPushDeps, ...d };
+}
+const result = (repoId, outcome, code, error, pr = null) => ({ repoId, outcome, prNumber: pr?.number ?? null, prUrl: pr?.url ?? null, code, error });
+/** The body of one of the pair (pure apart from the shared builders): the usual body, then the pair line. */
+export function hotfixPrBody(build, repo, o) {
+    const base = storyBuildPrBody({
+        summary: repo.summary ?? null,
+        ticketKey: build.ticketKey,
+        ticketTitle: build.ticketTitle ?? build.seedJson?.story.title ?? null,
+        ticketUrl: build.seedJson?.story.url ?? null,
+        covers: coveredBy(build, repo),
+        siblings: [],
+        stackedOnPrNumber: null,
+        // A hotfix is closed by the default-branch PR only (the release PR merges into a side branch).
+        closes: o.self === 'main' ? closesFor(build, o.includedRepos) : null,
+    });
+    const where = o.self === 'release' ? `**Release:** this fixes ${o.tagName}.` : `**Release:** this ports the fix for ${o.tagName} to ${o.defaultBranch}.`;
+    // THE PORT REPORT's one line (the agent's claim; null when there is none or the patches contradict it).
+    // Untrusted model text: defanged like every other text sent to GitHub.
+    const port = storyBuildRepoPort(repo);
+    const portLine = hotfixPortBodyLine(port);
+    const adapted = port.flag == null && port.claim?.outcome === 'adapted';
+    return [
+        base,
+        '',
+        where,
+        ...(portLine != null ? [defangGithubText(portLine)] : []),
+        ...(o.paired ? [hotfixPairLine(o.self, { tagName: o.tagName, defaultBranch: o.defaultBranch, other: o.other, adapted })] : []),
+    ].join('\n');
+}
+export async function pushHotfixRepo(ctx, a) {
+    if (a.branch !== undefined)
+        return result(a.repoId, 'failed', 'PUSH_DENIED', 'A hotfix build pushes the ticket-key branches. Discard it and start again to use another name.');
+    const build = await getStoryBuildRow(ctx, a.accountId, a.buildId);
+    if (!build)
+        return result(a.repoId, 'failed', 'NotFound', 'Build not found.');
+    const repo = await getStoryBuildRepoRow(ctx, a.accountId, a.buildId, a.repoId);
+    if (!repo)
+        return result(a.repoId, 'failed', 'NotFound', 'This repository is not part of the build.');
+    if (repo.status === 'pushed') {
+        const pr = repo.pushedPrNumber != null ? { number: repo.pushedPrNumber, url: repo.pushedPrUrl ?? '' } : null;
+        return result(a.repoId, 'skipped', 'ALREADY_PUSHED', null, pr);
+    }
+    if (repo.readOnly)
+        return result(a.repoId, 'skipped', 'READ_ONLY', 'This repository has no release yet, so it is read only in this hotfix build.');
+    if (!repo.include)
+        return result(a.repoId, 'skipped', 'NOT_INCLUDED', null);
+    if (build.status !== 'ready') {
+        const why = build.status === 'building' ? 'Wait for the build to finish.' : 'This build has nothing to push.';
+        return result(a.repoId, 'failed', build.status === 'building' ? 'BUSY' : 'NOT_READY', why);
+    }
+    if (repo.status !== 'ready' || repo.hotfixTag == null)
+        return result(a.repoId, 'failed', 'NOT_READY', 'This repository has nothing to push.');
+    if (pushing.has(repo.id))
+        return result(a.repoId, 'skipped', 'PUSH_IN_PROGRESS', 'This repository is being pushed.');
+    pushing.add(repo.id);
+    try {
+        return await pushClaimed(ctx, a, build, repo);
+    }
+    finally {
+        pushing.delete(repo.id);
+    }
+}
+async function pushClaimed(ctx, a, build, repo) {
+    const tagName = repo.hotfixTag;
+    const releaseSha = repo.baseSha;
+    const fail = async (code, message, main = false) => {
+        await updateStoryBuildRepo(ctx, a.accountId, repo.id, main ? { mainPushError: message, mainPushErrorCode: code } : { pushError: message, pushErrorCode: code }).catch(() => { });
+        return result(a.repoId, 'failed', code, message);
+    };
+    if (!(await deps.canPush(ctx, a.accountId, repo.repoId)))
+        return fail('NO_PUSH_PERMISSION', 'You cannot push to this repository.');
+    const names = await storyBuildRepoNames(ctx, a.accountId, [repo.repoId]);
+    const fullName = names.get(repo.repoId) ?? null;
+    const [owner, name] = (fullName ?? '').split('/');
+    if (!fullName || !owner || !name)
+        return fail('NotFound', 'This repository is not known here any more.');
+    const facts = await repoFacts(ctx, a.accountId, repo.repoId);
+    const defaultBranch = facts?.defaultBranch ?? (repo.mainBaseRef && repo.mainBaseRef !== 'HEAD' ? repo.mainBaseRef : null);
+    if (!defaultBranch)
+        return fail('NOT_READY', 'The default branch of this repository is not known yet. Try again after the next sync.');
+    const branch = (repo.branch ?? '').trim() || sessionBranch(build.ticketKey);
+    const targets = hotfixPushTargets({ branch, tagName, defaultBranch });
+    const protect = [...new Set([defaultBranch, targets.release.base, tagName])];
+    const title = storyBuildPrTitle(build.ticketKey, build.ticketTitle ?? build.seedJson?.story.title ?? null, repo.commitMessage ?? repo.mainCommitMessage ?? null);
+    const included = (await listStoryBuildRepoRows(ctx, a.accountId, build.id)).filter((r) => r.include && !r.readOnly).length;
+    const token = await deps.token(a.accountId);
+    const afterSync = (prNumber) => linkTicket(ctx, a.accountId, repo.repoId, prNumber, build.ident);
+    let releasePr = repo.pushedPrNumber != null ? { number: repo.pushedPrNumber, url: repo.pushedPrUrl ?? null } : null;
+    let mainPr = repo.mainPushedPrNumber != null ? { number: repo.mainPushedPrNumber, url: repo.mainPushedPrUrl ?? null } : null;
+    // Both already open at the press: PR 1's body was linked then (or that one edit failed: never retried).
+    let releaseBodyLinked = releasePr != null && mainPr != null;
+    const releaseWanted = repo.patch != null && repo.patch !== '';
+    const mainWanted = (repo.mainStatus === 'ready' || repo.mainStatus === 'pushed') && repo.mainPatch != null && repo.mainPatch !== '';
+    const paired = releaseWanted && mainWanted;
+    // ── 1 + 2: the hotfix branch, then PR 1 (the release fix). ──
+    if (releaseWanted && releasePr == null) {
+        let live;
+        try {
+            live = await deps.branchSha(token, owner, name, targets.release.base);
+        }
+        catch {
+            live = null;
+        }
+        let created = false;
+        if (hotfixBranchState(live, releaseSha) === 'missing') {
+            try {
+                const r = await deps.createBranch(token, { owner, name, branch: targets.release.base, sha: releaseSha });
+                created = r.outcome === 'created';
+                live = created ? releaseSha : await deps.branchSha(token, owner, name, targets.release.base).catch(() => null);
+            }
+            catch (err) {
+                return fail('BRANCH_NOT_CREATED', `GitHub did not make ${targets.release.base} on ${fullName}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+            if (live == null)
+                return fail('BRANCH_NOT_CREATED', `${targets.release.base} could not be read on ${fullName}. Try again.`);
+        }
+        const moved = hotfixBranchState(live, releaseSha) === 'moved';
+        // The branch was already there (an earlier hotfix off this release): name the PRs open on it,
+        // whether or not it has moved — an open, unmerged PR 1 leaves it at the release commit.
+        const prs = !created ? await deps.openPrsOnBase(token, owner, name, targets.release.base).catch(() => []) : [];
+        const record = { name: targets.release.base, releaseSha, created, movedToSha: moved ? live : null, prs, at: deps.now().toISOString() };
+        await updateStoryBuildRepo(ctx, a.accountId, repo.id, { hotfixBranchJson: record });
+        const body = hotfixPrBody(build, repo, { self: 'release', tagName, defaultBranch, other: mainPr, paired, includedRepos: included });
+        try {
+            const pushed = await deps.pushAndOpen({
+                accountId: a.accountId,
+                owner,
+                name,
+                baseSha: releaseSha,
+                baseRef: targets.release.base,
+                patch: repo.patch,
+                commitMessage: defangGithubText((repo.commitMessage ?? '').trim() || title, { mentions: false }),
+                branch: targets.release.head,
+                prBase: targets.release.base,
+                title,
+                body,
+                draft: a.draft,
+                protect: [...protect, targets.main.head],
+                afterSync,
+            });
+            releasePr = { number: pushed.prNumber, url: pushed.prUrl };
+            releaseBodyLinked = mainPr != null;
+            await updateStoryBuildRepo(ctx, a.accountId, repo.id, {
+                branch,
+                pushedBranch: pushed.pushedBranch,
+                pushedPrNumber: pushed.prNumber,
+                pushedPrUrl: pushed.prUrl,
+                pushedCommitSha: pushed.commitSha,
+                pushedAt: deps.now(),
+                prTitle: title,
+                prBody: body,
+                pushError: null,
+                pushErrorCode: null,
+            });
+        }
+        catch (err) {
+            return pushFailed(ctx, a, repo, err, targets.release.head, fullName, false);
+        }
+    }
+    // ── 3: PR 2 (the main fix). ──
+    if (mainWanted && mainPr == null) {
+        const body = hotfixPrBody(build, repo, { self: 'main', tagName, defaultBranch, other: releasePr, paired, includedRepos: included });
+        try {
+            const pushed = await deps.pushAndOpen({
+                accountId: a.accountId,
+                owner,
+                name,
+                baseSha: repo.mainBaseSha ?? '',
+                baseRef: defaultBranch,
+                patch: repo.mainPatch,
+                commitMessage: defangGithubText((repo.mainCommitMessage ?? repo.commitMessage ?? '').trim() || title, { mentions: false }),
+                branch: targets.main.head,
+                prBase: targets.main.base,
+                title,
+                body,
+                draft: a.draft,
+                protect: [...protect, targets.release.head],
+                afterSync,
+            });
+            mainPr = { number: pushed.prNumber, url: pushed.prUrl };
+            await updateStoryBuildRepo(ctx, a.accountId, repo.id, {
+                mainStatus: 'pushed',
+                mainPushedBranch: pushed.pushedBranch,
+                mainPushedPrNumber: pushed.prNumber,
+                mainPushedPrUrl: pushed.prUrl,
+                mainPushedCommitSha: pushed.commitSha,
+                mainPushedAt: deps.now(),
+                mainPushError: null,
+                mainPushErrorCode: null,
+            });
+        }
+        catch (err) {
+            return pushFailed(ctx, a, repo, err, targets.main.head, fullName, true);
+        }
+    }
+    // ── 4: PR 1's body links PR 2, once. A failure is a line, never retried. ──
+    if (releasePr != null && mainPr != null && !releaseBodyLinked) {
+        const body = hotfixPrBody(build, repo, { self: 'release', tagName, defaultBranch, other: mainPr, paired, includedRepos: included });
+        const r = await deps.updateBody(token, owner, name, releasePr.number, body).catch((err) => ({ ok: false, message: err instanceof Error ? err.message : String(err) }));
+        if (r.ok)
+            await updateStoryBuildRepo(ctx, a.accountId, repo.id, { prBody: body }).catch(() => { });
+        else
+            ctx.log.warn(`story build ${build.id}: linking the hotfix pair failed: ${r.message ?? ''}`);
+    }
+    const done = (!releaseWanted || releasePr != null) && (!mainWanted || mainPr != null);
+    if (done) {
+        await updateStoryBuildRepo(ctx, a.accountId, repo.id, { status: 'pushed' }).catch(() => { });
+        // Nothing left to push: the session's pinned base commits (release AND main) are needed no more.
+        const after = await listStoryBuildRepoRows(ctx, a.accountId, build.id).catch(() => null);
+        if (after != null && after.every((r) => !r.include || r.status !== 'ready')) {
+            const all = await storyBuildRepoNames(ctx, a.accountId, after.map((r) => r.repoId)).catch(() => new Map());
+            void dropSessionBaseRefs([...all.values(), fullName], build.id);
+        }
+    }
+    const shown = releasePr ?? mainPr;
+    return result(a.repoId, 'pushed', null, null, shown ? { number: shown.number, url: shown.url ?? '' } : null);
+}
+async function pushFailed(ctx, a, repo, err, branch, fullName, main) {
+    const code = err?.code ?? 'failed';
+    const message = code === 'BRANCH_EXISTS'
+        ? `A branch named ${branch} already exists on ${fullName}. Delete it on GitHub or discard this build.`
+        : err instanceof Error
+            ? err.message
+            : String(err);
+    if (code !== 'BRANCH_EXISTS' && code !== 'PR_NOT_OPENED' && code !== 'PUSH_DENIED' && code !== 'APPLY_FAILED')
+        ctx.log.warn({ err }, 'story build hotfix push failed');
+    await updateStoryBuildRepo(ctx, a.accountId, repo.id, main
+        ? { mainPushError: message, mainPushErrorCode: code, ...(code === 'PR_NOT_OPENED' ? { mainPushedBranch: branch, mainPushedCommitSha: err.commitSha ?? null } : {}) }
+        : { pushError: message, pushErrorCode: code, ...(code === 'PR_NOT_OPENED' ? { pushedBranch: branch, pushedCommitSha: err.commitSha ?? null } : {}) }).catch(() => { });
+    return result(a.repoId, 'failed', code, message);
+}
+//# sourceMappingURL=push-hotfix.js.map

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

@@ -242,6 +242,11 @@ export const pushRepo = async (ctx, a) => {
     const build = await getStoryBuildRow(ctx, a.accountId, a.buildId);
     if (!build)
         return result(a.repoId, 'failed', 'NotFound', 'Build not found.');
+    // A HOTFIX build pushes two PRs per repository (push-hotfix.ts; docs/STORY-BUILD.md § Hotfix builds).
+    if (build.hotfix === true) {
+        const { pushHotfixRepo } = await import('./push-hotfix.js');
+        return pushHotfixRepo(ctx, a);
+    }
     const repo = await getStoryBuildRepoRow(ctx, a.accountId, a.buildId, a.repoId);
     if (!repo)
         return result(a.repoId, 'failed', 'NotFound', 'This repository is not part of the build.');

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

@@ -1,4 +1,4 @@
-import { STORY_BUILD_API, STORY_BUILD_BRANCH_MAX, STORY_BUILD_PUSH_DRAFT_DEFAULT, storyBuildActivityOf, } from '../../shared/index.js';
+import { HOTFIX_NO_LOOP_LINE, STORY_BUILD_API, STORY_BUILD_BRANCH_MAX, STORY_BUILD_PUSH_DRAFT_DEFAULT, storyBuildActivityOf, } from '../../shared/index.js';
 import { resolveWorkspaceScope } from '../../db/queries.js';
 import { getStoryBuildRepoPatch, getStoryBuildRepoRow, getStoryBuildRow, listActiveStoryBuildRows, updateStoryBuild } from './persist.js';
 import { getStoryBuildPrRow, latestPlanRow, toPlanRevision } from './plan-persist.js';
@@ -116,10 +116,15 @@ export function registerStoryBuildBuildRoutes(app, ctx, push = pushRepo, pushPr
         const repoId = parseId(req.params.repoId);
         if (id == null || repoId == null)
             return reply.code(404).send(NOT_FOUND);
-        const got = await getStoryBuildRepoPatch(ctx, accountId, id, repoId);
+        // `?target=main`: a HOTFIX build's MAIN FIX (404 on a row without a main checkout).
+        const raw = req.query?.target;
+        if (raw !== undefined && raw !== 'release' && raw !== 'main')
+            return reply.code(400).send({ error: 'BadRequest', message: '`target` must be release or main.' });
+        const target = raw === 'main' ? 'main' : 'release';
+        const got = await getStoryBuildRepoPatch(ctx, accountId, id, repoId, target);
         if (!got)
             return reply.code(404).send(NOT_FOUND);
-        const resp = { repoId, baseSha: got.baseSha, patch: got.patch, filesChanged: got.filesChanged };
+        const resp = { repoId, baseSha: got.baseSha, patch: got.patch, filesChanged: got.filesChanged, target };
         return reply.send(resp);
     });
     app.post(STORY_BUILD_API.repoPush, async (req, reply) => {
@@ -184,6 +189,13 @@ export function registerStoryBuildBuildRoutes(app, ctx, push = pushRepo, pushPr
         const on = b != null && typeof b === 'object' && !Array.isArray(b) ? b.on : undefined;
         if (typeof on !== 'boolean')
             return reply.code(400).send({ error: 'BadRequest', message: '`on` must be true or false.' });
+        if (on) {
+            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 setStoryBuildAutoPush(ctx, accountId, id, on);
         if (r.status === 'not_found')
             return reply.code(404).send(NOT_FOUND);
@@ -229,6 +241,16 @@ export function registerStoryBuildBuildRoutes(app, ctx, push = pushRepo, pushPr
         const resp = { ticketReviewDoneAt: at?.toISOString() ?? null };
         return reply.send(resp);
     });
+    // HOTFIX (docs/STORY-BUILD.md § Hotfix builds): the Start panel's base list — each workspace repository's
+    // latest release, or read only — and whether "Treat as a hotfix" is offered. DB only (the synced tags).
+    app.get(STORY_BUILD_API.hotfixBases, async (req, reply) => {
+        const accountId = ctx.accountIdOf(req);
+        // The session's own scope: EVERY member, external repos included (sandbox/session/routes.ts's start).
+        const scope = await resolveWorkspaceScope(accountId, req.query.workspace ?? null, null, { members: 'all' });
+        const { sessionHotfixBases } = await import('../../sandbox/session/manager.js');
+        const resp = await sessionHotfixBases(accountId, scope.workspaceId, scope.repoIds);
+        return reply.send(resp);
+    });
     // THE BUILDS TOAST (shared story-build-activity.ts): one row per build that runs or waits at a gate. DB
     // plus the in-process live map; never a tracker, GitHub or model call.
     app.get(STORY_BUILD_API.active, async (req, reply) => {

package/dist/db/erase-account.js

@@ -95,6 +95,14 @@ export async function eraseAccountData(accountId) {
         await tx.delete(workspaceRepos).where(eq(workspaceRepos.accountId, accountId)).execute();
         // The EXTRA External memberships (migration 0191) — same shape, same reason.
         await tx.delete(workspaceExternalRepos).where(eq(workspaceExternalRepos.accountId, accountId)).execute();
+        // RELEASES (migration 0195): child before parent (both children's composite FKs point at
+        // `releases`, which points at `workspaces`), then the synced tags and their ranges. The repo and
+        // workspace cascades normally take them; explicit so the guarantee depends on neither.
+        await tx.delete(schema.releaseTicketComments).where(eq(schema.releaseTicketComments.accountId, accountId)).execute();
+        await tx.delete(schema.releaseItems).where(eq(schema.releaseItems.accountId, accountId)).execute();
+        await tx.delete(schema.releases).where(eq(schema.releases.accountId, accountId)).execute();
+        await tx.delete(schema.repoTagRanges).where(eq(schema.repoTagRanges.accountId, accountId)).execute();
+        await tx.delete(schema.repoTags).where(eq(schema.repoTags.accountId, accountId)).execute();
         // Story chats (migration 0192): turns first (their FK names the chat), then the chats.
         await tx.delete(schema.storyChatTurns).where(eq(schema.storyChatTurns.accountId, accountId)).execute();
         await tx.delete(schema.storyChats).where(eq(schema.storyChats.accountId, accountId)).execute();
@@ -495,6 +503,12 @@ export function accountScopedTables() {
         { name: 'workspaceRepos', col: workspaceRepos.accountId, table: workspaceRepos },
         // The EXTRA External memberships (migration 0191): a repo External in more than one workspace.
         { name: 'workspaceExternalRepos', col: workspaceExternalRepos.accountId, table: workspaceExternalRepos },
+        // RELEASES (migration 0195): the synced tags, their ranges, and every release the reader made.
+        { name: 'repoTags', col: schema.repoTags.accountId, table: schema.repoTags },
+        { name: 'repoTagRanges', col: schema.repoTagRanges.accountId, table: schema.repoTagRanges },
+        { name: 'releases', col: schema.releases.accountId, table: schema.releases },
+        { name: 'releaseItems', col: schema.releaseItems.accountId, table: schema.releaseItems },
+        { name: 'releaseTicketComments', col: schema.releaseTicketComments.accountId, table: schema.releaseTicketComments },
         // Story chats (migration 0192): the reader's questions and the answers.
         { name: 'storyChats', col: schema.storyChats.accountId, table: schema.storyChats },
         { name: 'storyChatTurns', col: schema.storyChatTurns.accountId, table: schema.storyChatTurns },

package/dist/db/hotfix-bases.js

@@ -0,0 +1,31 @@
+// HOTFIX BASES (docs/STORY-BUILD.md § Hotfix builds, docs/RELEASES.md § Hotfix) — DB only, account-scoped.
+// Per workspace repository its LATEST RELEASE (the newest release OR hotfix tag, shared `latestReleaseTag`)
+// from the synced tags (`repo_tags`), through the ONE pure fold `hotfixBasesOf`. The Start panel's base list
+// (`GET /api/story-builds/hotfix-bases`) and the session's bases (sandbox/session/manager.ts) both read it, so
+// what the reader saw at Start is what the build starts from. Never a GitHub or tracker call.
+import { and, eq, inArray } from 'drizzle-orm';
+import { hotfixBasesOf } from '../shared/index.js';
+import { db, schema } from './client.js';
+import { getReleaseSettings } from './release-settings.js';
+import { getRepoTags } from './repo-tags.js';
+const { repos } = schema;
+/** The hotfix bases of `repoIds` (the workspace's members, external included) under the workspace's suffixes. */
+export async function getHotfixBases(accountId, workspaceId, repoIds) {
+    const settings = (await getReleaseSettings(accountId, workspaceId)) ?? { releaseSuffix: null, hotfixSuffix: null };
+    const rows = repoIds.length === 0
+        ? []
+        : await db
+            .select({ id: repos.id, owner: repos.owner, name: repos.name, defaultBranch: repos.defaultBranch, defaultBranchName: repos.defaultBranchName })
+            .from(repos)
+            .where(and(eq(repos.accountId, accountId), inArray(repos.id, [...repoIds])))
+            .execute();
+    const tags = await getRepoTags(accountId, rows.map((r) => r.id));
+    const folded = hotfixBasesOf(rows.map((r) => ({
+        repoId: r.id,
+        fullName: `${r.owner}/${r.name}`,
+        defaultBranch: r.defaultBranch ?? r.defaultBranchName ?? null,
+        tags: tags.filter((t) => t.repoId === r.id).map((t) => ({ name: t.name, sha: t.sha, committedAt: t.committedAt, taggedAt: t.taggedAt })),
+    })), settings);
+    return { workspaceId, ...folded };
+}
+//# sourceMappingURL=hotfix-bases.js.map

package/dist/db/migrations/0195_releases.sql

@@ -0,0 +1,128 @@
+-- RELEASES (2026-11-14; docs/RELEASES.md). CORE, additive.
+--
+--   pull_requests.merge_commit_oid   the commit a PR landed as (GraphQL mergeCommit.oid). Cleared only
+--                                    on a positive statement (sync/upsert.ts).
+--   workspaces.release_suffix /      the per-workspace release and hotfix tag suffixes. NULL = not set;
+--   workspaces.hotfix_suffix         no default (shared validateReleaseSettings).
+--   repos.tags_signature / tags_synced_at   what the last complete tag read saw (sync/repo-tags.ts).
+--   repo_tags                        NEW: one row per (account, repo, tag name).
+--   repo_tag_ranges                  NEW: the PRs between a tag and the tag before it.
+--   releases / release_items / release_ticket_comments   NEW: one press of "Create release…", its
+--                                    per-repo writes and its per-ticket tracker comments.
+ALTER TABLE `pull_requests` ADD COLUMN `merge_commit_oid` text;
+--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS `pr_account_repo_merge_commit_idx` ON `pull_requests` (`account_id`,`repo_id`,`merge_commit_oid`);
+--> statement-breakpoint
+ALTER TABLE `workspaces` ADD COLUMN `release_suffix` text;
+--> statement-breakpoint
+ALTER TABLE `workspaces` ADD COLUMN `hotfix_suffix` text;
+--> statement-breakpoint
+ALTER TABLE `repos` ADD COLUMN `tags_signature` text;
+--> statement-breakpoint
+ALTER TABLE `repos` ADD COLUMN `tags_synced_at` integer;
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS `repo_tags` (
+	`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	`account_id` integer NOT NULL,
+	`repo_id` integer NOT NULL,
+	`name` text NOT NULL,
+	`sha` text NOT NULL,
+	`tag_object_oid` text,
+	`committed_at` integer,
+	`tagged_at` integer,
+	`on_default_branch` integer,
+	`ancestry_head_sha` text,
+	`previous_sha` text,
+	`moved_at` integer,
+	`first_seen_at` integer NOT NULL,
+	`last_seen_at` integer NOT NULL,
+	FOREIGN KEY (`account_id`) REFERENCES `accounts`(`id`) ON UPDATE no action ON DELETE cascade,
+	CONSTRAINT `repo_tags_repo_account_fk` FOREIGN KEY (`repo_id`,`account_id`) REFERENCES `repos`(`id`,`account_id`) ON UPDATE no action ON DELETE cascade
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX IF NOT EXISTS `repo_tags_account_repo_name` ON `repo_tags` (`account_id`,`repo_id`,`name`);
+--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS `repo_tags_account_repo_sha_idx` ON `repo_tags` (`account_id`,`repo_id`,`sha`);
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS `repo_tag_ranges` (
+	`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	`account_id` integer NOT NULL,
+	`repo_id` integer NOT NULL,
+	`tag_name` text NOT NULL,
+	`sha` text NOT NULL,
+	`base_tag_name` text,
+	`base_sha` text,
+	`method` text NOT NULL,
+	`pr_numbers` text NOT NULL,
+	`commit_count` integer DEFAULT 0 NOT NULL,
+	`unmatched_commits` integer DEFAULT 0 NOT NULL,
+	`truncated` integer DEFAULT 0 NOT NULL,
+	`moved_from_sha` text,
+	`computed_at` integer NOT NULL,
+	FOREIGN KEY (`account_id`) REFERENCES `accounts`(`id`) ON UPDATE no action ON DELETE cascade,
+	CONSTRAINT `repo_tag_ranges_repo_account_fk` FOREIGN KEY (`repo_id`,`account_id`) REFERENCES `repos`(`id`,`account_id`) ON UPDATE no action ON DELETE cascade
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX IF NOT EXISTS `repo_tag_ranges_account_repo_tag` ON `repo_tag_ranges` (`account_id`,`repo_id`,`tag_name`);
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS `releases` (
+	`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	`account_id` integer NOT NULL,
+	`workspace_id` integer NOT NULL,
+	`created_by_user_id` integer,
+	`created_by_login` text,
+	`created_at` integer NOT NULL,
+	`release_suffix` text NOT NULL,
+	`notes_markdown` text DEFAULT '' NOT NULL,
+	`state` text NOT NULL,
+	`finished_at` integer,
+	FOREIGN KEY (`account_id`) REFERENCES `accounts`(`id`) ON UPDATE no action ON DELETE cascade,
+	FOREIGN KEY (`created_by_user_id`) REFERENCES `users`(`id`) ON UPDATE no action ON DELETE no action,
+	CONSTRAINT `releases_workspace_account_fk` FOREIGN KEY (`workspace_id`,`account_id`) REFERENCES `workspaces`(`id`,`account_id`) ON UPDATE no action ON DELETE cascade
+);
+--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS `releases_account_workspace_idx` ON `releases` (`account_id`,`workspace_id`,`created_at`);
+--> statement-breakpoint
+CREATE UNIQUE INDEX IF NOT EXISTS `releases_id_account` ON `releases` (`id`,`account_id`);
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS `release_items` (
+	`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	`account_id` integer NOT NULL,
+	`release_id` integer NOT NULL,
+	`repo_id` integer NOT NULL,
+	`version_tag` text NOT NULL,
+	`sha` text NOT NULL,
+	`release_tag_name` text NOT NULL,
+	`notes_markdown` text DEFAULT '' NOT NULL,
+	`tag_state` text DEFAULT 'pending' NOT NULL,
+	`tag_object_oid` text,
+	`prerelease_state` text DEFAULT 'pending' NOT NULL,
+	`github_release_id` integer,
+	`github_release_url` text,
+	`error` text,
+	`updated_at` integer NOT NULL,
+	FOREIGN KEY (`account_id`) REFERENCES `accounts`(`id`) ON UPDATE no action ON DELETE cascade,
+	CONSTRAINT `release_items_release_account_fk` FOREIGN KEY (`release_id`,`account_id`) REFERENCES `releases`(`id`,`account_id`) ON UPDATE no action ON DELETE cascade,
+	CONSTRAINT `release_items_repo_account_fk` FOREIGN KEY (`repo_id`,`account_id`) REFERENCES `repos`(`id`,`account_id`) ON UPDATE no action ON DELETE cascade
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX IF NOT EXISTS `release_items_account_release_repo` ON `release_items` (`account_id`,`release_id`,`repo_id`);
+--> statement-breakpoint
+CREATE UNIQUE INDEX IF NOT EXISTS `release_items_account_repo_tag` ON `release_items` (`account_id`,`repo_id`,`release_tag_name`);
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS `release_ticket_comments` (
+	`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	`account_id` integer NOT NULL,
+	`release_id` integer NOT NULL,
+	`ticket_key` text NOT NULL,
+	`tracker_kind` text,
+	`state` text DEFAULT 'pending' NOT NULL,
+	`comment_id` text,
+	`error` text,
+	`claimed_at` integer,
+	`posted_at` integer,
+	FOREIGN KEY (`account_id`) REFERENCES `accounts`(`id`) ON UPDATE no action ON DELETE cascade,
+	CONSTRAINT `release_ticket_comments_release_account_fk` FOREIGN KEY (`release_id`,`account_id`) REFERENCES `releases`(`id`,`account_id`) ON UPDATE no action ON DELETE cascade
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX IF NOT EXISTS `release_ticket_comments_account_release_ticket` ON `release_ticket_comments` (`account_id`,`release_id`,`ticket_key`);

package/dist/db/migrations/0196_story_build_hotfix.sql

@@ -0,0 +1,54 @@
+-- IMPLEMENT STORY: HOTFIX BUILDS (2026-11-15; docs/STORY-BUILD.md § Hotfix builds, docs/RELEASES.md § Hotfix).
+-- CORE, additive. A hotfix build fixes each repository on its LATEST RELEASE and ports the fix to the
+-- default branch in the same sandbox; Push opens two PRs per repository.
+--
+--   story_builds.hotfix                       1 = "Treat as a hotfix" was ticked at Start. 0 = an ordinary build.
+--   story_build_repos.hotfix_tag              the latest release (or hotfix) tag the release checkout starts at;
+--                                             NULL on an ordinary build and on a READ-ONLY repository.
+--   story_build_repos.read_only               1 = no release yet: the agent may read it, its changes are refused.
+--   story_build_repos.main_*                  the MAIN FIX: the default-branch checkout's base, sandbox path,
+--                                             patch (+ sha, numbers, files, commit message), its status
+--                                             (NULL | ready | skipped | failed | pushed) and its push record.
+--   story_build_repos.hotfix_branch_json      Push's record of `hotfix/<tag>`: created or found, moved past the
+--                                             release commit, and the PRs already on it.
+ALTER TABLE `story_builds` ADD COLUMN `hotfix` integer NOT NULL DEFAULT 0;
+--> statement-breakpoint
+ALTER TABLE `story_build_repos` ADD COLUMN `hotfix_tag` text;
+--> statement-breakpoint
+ALTER TABLE `story_build_repos` ADD COLUMN `read_only` integer NOT NULL DEFAULT 0;
+--> statement-breakpoint
+ALTER TABLE `story_build_repos` ADD COLUMN `main_base_ref` text;
+--> statement-breakpoint
+ALTER TABLE `story_build_repos` ADD COLUMN `main_base_sha` text;
+--> statement-breakpoint
+ALTER TABLE `story_build_repos` ADD COLUMN `main_sandbox_path` text;
+--> statement-breakpoint
+ALTER TABLE `story_build_repos` ADD COLUMN `main_patch` text;
+--> statement-breakpoint
+ALTER TABLE `story_build_repos` ADD COLUMN `main_patch_sha` text;
+--> statement-breakpoint
+ALTER TABLE `story_build_repos` ADD COLUMN `main_stat_json` text;
+--> statement-breakpoint
+ALTER TABLE `story_build_repos` ADD COLUMN `main_files_changed_json` text;
+--> statement-breakpoint
+ALTER TABLE `story_build_repos` ADD COLUMN `main_commit_message` text;
+--> statement-breakpoint
+ALTER TABLE `story_build_repos` ADD COLUMN `main_status` text;
+--> statement-breakpoint
+ALTER TABLE `story_build_repos` ADD COLUMN `main_error` text;
+--> statement-breakpoint
+ALTER TABLE `story_build_repos` ADD COLUMN `main_pushed_branch` text;
+--> statement-breakpoint
+ALTER TABLE `story_build_repos` ADD COLUMN `main_pushed_pr_number` integer;
+--> statement-breakpoint
+ALTER TABLE `story_build_repos` ADD COLUMN `main_pushed_pr_url` text;
+--> statement-breakpoint
+ALTER TABLE `story_build_repos` ADD COLUMN `main_pushed_commit_sha` text;
+--> statement-breakpoint
+ALTER TABLE `story_build_repos` ADD COLUMN `main_pushed_at` integer;
+--> statement-breakpoint
+ALTER TABLE `story_build_repos` ADD COLUMN `main_push_error` text;
+--> statement-breakpoint
+ALTER TABLE `story_build_repos` ADD COLUMN `main_push_error_code` text;
+--> statement-breakpoint
+ALTER TABLE `story_build_repos` ADD COLUMN `hotfix_branch_json` text;

package/dist/db/migrations/0197_release_items_live_tag.sql

@@ -0,0 +1,11 @@
+-- RELEASES: A FAILED RELEASE TAG NO LONGER HOLDS ITS NAME (2026-11-15; docs/RELEASES.md § Implementation).
+-- CORE. The unique (account, repo, release_tag_name) on release_items made a FAILED or REFUSED tag
+-- write hold the name for good: every later press for that version was told "already made". The
+-- name is now held only by a LIVE row (pending / claimed / done) — a partial unique index, declared
+-- here only (like `workspaces_one_default`). A failed or refused row stays as that release's history;
+-- a new press is a new claim on a new row (still claimed before the write, never retried).
+DROP INDEX IF EXISTS `release_items_account_repo_tag`;
+--> statement-breakpoint
+CREATE UNIQUE INDEX IF NOT EXISTS `release_items_account_repo_tag_live` ON `release_items` (`account_id`,`repo_id`,`release_tag_name`) WHERE `tag_state` IN ('pending', 'claimed', 'done');
+--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS `release_items_account_repo_tag_idx` ON `release_items` (`account_id`,`repo_id`,`release_tag_name`);

package/dist/db/migrations/0198_story_build_port_report.sql

@@ -0,0 +1,7 @@
+-- IMPLEMENT STORY: THE HOTFIX PORT REPORT (2026-11-15; docs/STORY-BUILD.md § Hotfix builds → The port report,
+-- docs/RELEASES.md § Port report). CORE, additive.
+--
+--   story_build_repos.port_report_json   the agent's word on the port to the default branch for this repository:
+--                                        { outcome: same | adapted | not_needed, reason, evidence[] }, as the host
+--                                        checked and clipped it. NULL = no report (never inferred). Untrusted text.
+ALTER TABLE `story_build_repos` ADD COLUMN `port_report_json` text;