specrails-desktop 2.55.0 → 2.55.1

package/server/dist/modules/delivery/adapters/decisions/create.js

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCreatePr = runCreatePr;
+const pr_publisher_1 = require("../../runtime/pr-publisher");
+const rail_pr_delivery_1 = require("../../runtime/rail-pr-delivery");
+const rail_worktree_release_1 = require("../../runtime/rail-worktree-release");
+const pr_naming_1 = require("../../runtime/pr-naming");
+const pr_body_1 = require("../../runtime/pr-body");
+const ai_invocations_1 = require("../../../accounting/runtime/ai-invocations");
+const rail_pr_store_1 = require("../../runtime/rail-pr-store");
+const retry_1 = require("./retry");
+const evidence_1 = require("./evidence");
+const transitions_1 = require("./transitions");
+const metadata_1 = require("./metadata");
+const ownership_1 = require("./ownership");
+async function runCreatePr(deps, row) {
+    if (row.decision === 'pr_failed' && row.pr_url && row.branch) {
+        return (0, retry_1.retryExistingPrFollowupPush)(deps, row);
+    }
+    const snap = (0, rail_pr_store_1.toPrDeliverySnapshot)(row);
+    // Resolve every deliverable unit to an immutable object. New rows carry the
+    // verified final SHA from settlement; legacy rows may capture their recorded
+    // ref once. Never substitute another historical branch merely because it
+    // belongs to the same ticket.
+    let effectiveBranches = snap.branches;
+    let branchEvidenceCaptured = false;
+    const singleDeliverable = snap.branches.filter((unit) => unit.succeeded).length === 1;
+    const frozenSingleSha = singleDeliverable && row.delivery_sha && evidence_1.COMMIT_SHA_RE.test(row.delivery_sha) &&
+        await (0, evidence_1.commitObjectExists)(deps, row.delivery_sha)
+        ? row.delivery_sha
+        : null;
+    for (let index = 0; index < snap.branches.length; index++) {
+        const unit = snap.branches[index];
+        if (!unit.succeeded)
+            continue;
+        // A detached/stale single-unit delivery already has authoritative immutable
+        // evidence. Prefer it over both legacy unit gaps and a branch ref that may
+        // have advanced while the card waited for the user's decision.
+        let sourceSha = frozenSingleSha ?? (unit.finalSha && evidence_1.COMMIT_SHA_RE.test(unit.finalSha) ? unit.finalSha : null);
+        if (sourceSha) {
+            if (!(await (0, evidence_1.commitObjectExists)(deps, sourceSha)))
+                sourceSha = null;
+        }
+        else {
+            sourceSha = await (0, evidence_1.captureBranchSha)(deps, unit.branch);
+            if (sourceSha && !(await (0, evidence_1.commitObjectExists)(deps, sourceSha)))
+                sourceSha = null;
+        }
+        if (!sourceSha) {
+            const detail = `the verified commit for branch '${unit.branch}' (ticket #${unit.ticketId}) is unavailable; refusing to deliver a mutable or unrelated ref`;
+            const conflict = (0, transitions_1.casTransition)(deps, row, 'pr_failed', {
+                deliveryOutcome: 'blocked', statusCode: 'branch_verification_failed', statusDetail: detail,
+            });
+            if (conflict)
+                return conflict;
+            (0, transitions_1.finalizeTransition)(deps, row.id);
+            return { status: 200, body: { ok: true, decision: 'pr_failed', detail } };
+        }
+        if (unit.finalSha !== sourceSha)
+            branchEvidenceCaptured = true;
+        effectiveBranches = effectiveBranches.map((branch, branchIndex) => branchIndex === index
+            ? { ...branch, finalSha: sourceSha }
+            : branch);
+    }
+    // Succeeded COVERED tickets for the PR title/body: a single unit covers every
+    // launch ticket (scope='all'), per-ticket units cover exactly their own.
+    const succeededUnits = effectiveBranches.filter((b) => b.succeeded);
+    const succeededTicketIds = effectiveBranches.length === 1 && succeededUnits.length === 1
+        ? snap.ticketIds
+        : succeededUnits.map((b) => b.ticketId);
+    const ticketData = (0, metadata_1.loadPrTicketData)(deps, succeededTicketIds);
+    // The batch name is derived ONLY for multi-unit deliveries — the single-ticket
+    // path delivers straight from its unit branch and must never even compute one.
+    const batchPreferred = succeededUnits.length > 1 ? (0, pr_naming_1.batchBranchNameFor)(ticketData) : null;
+    const unitBranches = new Set(effectiveBranches.map((b) => b.branch));
+    // Per-ticket covering branch for the body's honest Tests digest: per-ticket
+    // units map 1:1; a single 'all'-scope unit covers every launch ticket.
+    const branchFor = (ticketId) => {
+        const unit = succeededUnits.find((b) => b.ticketId === ticketId);
+        if (unit)
+            return unit.branch;
+        return succeededUnits.length === 1 ? succeededUnits[0].branch : null;
+    };
+    // Diffstats are best-effort: a git failure degrades the body (section
+    // omitted / "diff unavailable" note), never blocks the PR.
+    let changes = null;
+    try {
+        changes = await (0, pr_body_1.collectBranchChanges)(deps.git, deps.project.path, row.base_branch, succeededUnits.map((b) => b.branch));
+    }
+    catch {
+        changes = null;
+    }
+    // Cost footer is best-effort: a lookup failure omits the line, never blocks.
+    let costUsd = null;
+    try {
+        costUsd = (0, ai_invocations_1.sumInvocationCostForRuns)(deps.db, snap.runIds);
+    }
+    catch {
+        costUsd = null;
+    }
+    const title = (0, pr_naming_1.buildPrTitle)(ticketData, { loopName: row.loop_name });
+    const body = (0, pr_body_1.buildCanonicalPrBody)({
+        loopName: row.loop_name,
+        baseBranch: row.base_branch,
+        tickets: ticketData.map((t) => ({ ...t, branch: branchFor(t.ticketId) })),
+        changes,
+        costUsd,
+    });
+    let next;
+    // Underlying git/gh failure detail for a degraded or failed delivery —
+    // relayed on the response and persisted as bounded secondary diagnostics.
+    let detail = null;
+    const patch = {};
+    if (branchEvidenceCaptured)
+        patch.branches = effectiveBranches;
+    try {
+        // A degraded multi-unit attempt already owns an assembled batch branch.
+        // Retry that exact head so exact head/base PR discovery remains idempotent;
+        // never `branch -D` a merely name-matching ref, which could destroy a user's
+        // unrelated or subsequently edited local branch.
+        let degradedBatchSha = null;
+        if (batchPreferred && row.branch && row.pr_url === null &&
+            (row.pr_state === 'pushed' || row.pr_state === 'local-only') &&
+            row.branch !== row.base_branch && !unitBranches.has(row.branch)) {
+            if (row.delivery_sha && await (0, evidence_1.commitObjectExists)(deps, row.delivery_sha)) {
+                degradedBatchSha = row.delivery_sha;
+            }
+            else {
+                degradedBatchSha = await (0, evidence_1.captureBranchSha)(deps, row.branch);
+            }
+        }
+        const result = degradedBatchSha
+            ? {
+                state: 'delivered',
+                branch: row.branch,
+                pr: await (0, pr_publisher_1.publishDraftPr)(deps.exec, {
+                    repoDir: deps.project.path,
+                    branch: row.branch,
+                    baseBranch: row.base_branch,
+                    title,
+                    body,
+                    sourceSha: degradedBatchSha,
+                }),
+                ticketIds: succeededTicketIds,
+            }
+            : await (0, rail_pr_delivery_1.deliverRailAsPr)(deps.git, deps.exec, {
+                baseRepo: deps.project.path,
+                integrationBranch: row.base_branch,
+                railKey: row.rail_key,
+                batchBranch: batchPreferred ?? undefined,
+                batchWorktreeRoot: (0, metadata_1.batchWorktreeRoot)(deps.project.slug),
+                branches: effectiveBranches.map((unit) => ({
+                    ...unit,
+                    sourceSha: unit.finalSha ?? undefined,
+                })),
+                title,
+                body,
+            });
+        if (result.state === 'delivered') {
+            next = result.pr.state === 'pr-created' && result.pr.isDraft === false ? 'pr_ready' : 'pr_draft';
+            patch.branch = result.branch;
+            patch.prState = result.pr.state;
+            const resultSha = degradedBatchSha
+                ?? (succeededUnits.length === 1 ? succeededUnits[0].finalSha ?? null : await (0, evidence_1.captureBranchSha)(deps, result.branch));
+            if (resultSha && await (0, evidence_1.commitObjectExists)(deps, resultSha))
+                patch.deliverySha = resultSha;
+            if (result.pr.state === 'pr-created' && result.pr.prUrl) {
+                patch.prUrl = result.pr.prUrl;
+                patch.prNumber = (0, metadata_1.parsePrNumber)(result.pr.prUrl);
+                patch.deliveryOutcome = 'delivered';
+                patch.statusCode = next === 'pr_ready' ? 'pr_ready' : 'pr_draft_ready';
+            }
+            else {
+                // Degraded (pushed / local-only): no PR exists — only retry or discard.
+                patch.prUrl = null;
+                patch.prNumber = null;
+                detail = result.pr.reason ?? null;
+                patch.deliveryOutcome = 'retryable_failure';
+                patch.statusCode = result.pr.state === 'local-only' ? 'push_failed' : 'delivery_failed';
+            }
+        }
+        else {
+            // 'assembly-failed' (or an unexpected 'no-op' — settle guarantees ≥1
+            // succeeded unit, but a wedged row must not 500) → retryable failure.
+            next = 'pr_failed';
+            detail = result.reason;
+            const retryable = !result.reason.startsWith('merge-conflict:') &&
+                !result.reason.startsWith('batch-branch-collision:') &&
+                result.reason !== 'missing-batch-branch' && result.state === 'assembly-failed';
+            patch.deliveryOutcome = retryable ? 'retryable_failure' : 'blocked';
+            patch.statusCode = 'delivery_failed';
+        }
+    }
+    catch (err) {
+        // publishDraftPr can propagate GitGuardrailError — a guardrail violation is
+        // a retryable delivery failure, never a crash.
+        console.error('[rail-pr-decision] create-pr delivery failed:', err);
+        next = 'pr_failed';
+        detail = err instanceof Error ? err.message : String(err);
+        patch.deliveryOutcome = 'blocked';
+        patch.statusCode = 'delivery_failed';
+    }
+    if (detail)
+        patch.statusDetail = detail;
+    if ((next === 'pr_draft' || next === 'pr_ready') && patch.prUrl) {
+        patch.cleanupWarnings = await (0, rail_worktree_release_1.releaseRailWorktrees)({
+            db: deps.db, git: deps.git, repoDir: deps.project.path, worktreeIds: (0, ownership_1.releasableWorktreeIds)(deps, snap),
+            expectedHeadByBranch: (0, rail_worktree_release_1.durableBranchHeads)(effectiveBranches),
+            overlayEvidenceByBranch: (0, rail_worktree_release_1.durableOverlayCleanupEvidence)(effectiveBranches),
+            settlementIgnoredByBranch: (0, rail_worktree_release_1.durableSettlementIgnoredPaths)(effectiveBranches),
+            onSafetyArchive: (0, transitions_1.safetyArchiveRecorder)(deps, row),
+        });
+        if (patch.cleanupWarnings.length > 0)
+            patch.statusCode = 'cleanup_incomplete';
+    }
+    const conflict = (0, transitions_1.casTransition)(deps, row, next, patch);
+    if (conflict)
+        return conflict;
+    if ((next === 'pr_draft' || next === 'pr_ready') && patch.prUrl) {
+        await (0, evidence_1.releaseDeliveredRecoveryLineage)(deps, row, patch.deliverySha ?? row.delivery_sha);
+    }
+    const after = (0, transitions_1.finalizeTransition)(deps, row.id);
+    // Tickets stay on_review — a draft PR is still awaiting the engineer's merge.
+    return {
+        status: 200,
+        body: {
+            ok: true,
+            decision: next,
+            prUrl: after?.prUrl ?? null,
+            prState: after?.prState ?? row.pr_state,
+            ...(detail ? { detail } : {}),
+        },
+    };
+}

package/server/dist/modules/delivery/adapters/decisions/discard.js

@@ -0,0 +1,251 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDiscard = runDiscard;
+exports.runDismiss = runDismiss;
+exports.runAcknowledgeNoChanges = runAcknowledgeNoChanges;
+const fs = __importStar(require("fs"));
+const rail_worktree_release_1 = require("../../runtime/rail-worktree-release");
+const rail_pr_store_1 = require("../../runtime/rail-pr-store");
+const rail_worktrees_store_1 = require("../../runtime/rail-worktrees-store");
+const rail_pr_recovery_git_1 = require("../../runtime/rail-pr-recovery-git");
+const transitions_1 = require("./transitions");
+const ownership_1 = require("./ownership");
+const evidence_1 = require("./evidence");
+const chains_1 = require("./chains");
+async function runDiscard(deps, row, opts = { removeNeedsReview: true }) {
+    const snap = (0, rail_pr_store_1.toPrDeliverySnapshot)(row);
+    const implementationFailed = row.decision === 'implementation_failed';
+    // PR lifecycle ownership and head-ref ownership are separate. Startup repairs
+    // historical continuation rows before admission opens; only that durable bit
+    // borrows the PR/ticket lifecycle. Per-unit ownership below independently
+    // prevents deletion of borrowed/pre-existing head refs for fresh replacements.
+    const preserveExternalReview = row.is_continuation === 1;
+    // A preparation failure never ran: no worktree, no branch, no commit, no PR.
+    // Discarding it only closes the attempt and frees the rail — the spec keeps
+    // the status it had (typically on_review from a still-open earlier PR), the
+    // backlog/Jira are not told about a delivery that never existed, and no
+    // resource cleanup can be owed. Distinct from implementation_failed, which
+    // did run and did move the ticket.
+    const preparationFailure = row.decision === 'pr_failed' &&
+        row.implementation_outcome === 'failed' &&
+        !row.pr_url && !row.delivery_sha && !preserveExternalReview &&
+        snap.branches.length === 0 && snap.worktreeIds.length === 0;
+    const cleanupWarnings = [];
+    // A continuation borrows an existing PR/head. Discarding its local iteration
+    // may remove Specrails' worktree, but never closes or deletes borrowed review
+    // state. A fresh PR is closed without GitHub's unleased --delete-branch: its
+    // remote head may have advanced since the card was rendered.
+    if (row.pr_url && !implementationFailed && !preserveExternalReview) {
+        try {
+            const r = await deps.exec.run('gh', ['pr', 'close', row.pr_url], deps.project.path);
+            if (r.code !== 0) {
+                const detail = (r.stderr.trim() || r.stdout.trim()).split('\n')[0] || `exit ${r.code}`;
+                cleanupWarnings.push(`PR close ${row.pr_url}: ${detail}`);
+                console.warn(`[rail-pr-decision] gh pr close failed (continuing discard): ${detail}`);
+            }
+        }
+        catch (err) {
+            cleanupWarnings.push(`PR close ${row.pr_url}: ${err instanceof Error ? err.message : String(err)}`);
+            console.warn('[rail-pr-decision] gh pr close threw (continuing discard):', err);
+        }
+    }
+    // 2. Release only worktrees whose live tracked/untracked/ignored state and
+    //    exact HEAD/ref still match durable settlement evidence. Explicit
+    //    discard is not permission to contradict the confirmation copy by
+    //    force-removing subsequently changed local work. Authenticated overlays
+    //    take the same lossless quarantine path as automatic settlement.
+    const deleteOwnedBranches = !implementationFailed && !preserveExternalReview;
+    const skippedNeedsReview = opts.removeNeedsReview === true
+        ? []
+        : snap.worktreeIds
+            .map((wtId) => (0, rail_worktrees_store_1.getRailWorktree)(deps.db, wtId))
+            .filter((wt) => wt?.merge_state === 'needs-review');
+    for (const worktree of skippedNeedsReview) {
+        cleanupWarnings.push(`worktree ${worktree.worktree_path}: preserved for inspection because it already requires review`);
+    }
+    const skippedIds = new Set(skippedNeedsReview.map((wt) => wt.id));
+    const worktreeIds = snap.worktreeIds.filter((wtId) => !skippedIds.has(wtId));
+    cleanupWarnings.push(...await (0, rail_worktree_release_1.releaseRailWorktrees)({
+        db: deps.db,
+        git: deps.git,
+        repoDir: deps.project.path,
+        worktreeIds,
+        state: 'failed',
+        expectedHeadByBranch: (0, rail_worktree_release_1.durableBranchHeads)(snap.branches),
+        overlayEvidenceByBranch: (0, rail_worktree_release_1.durableOverlayCleanupEvidence)(snap.branches),
+        settlementIgnoredByBranch: (0, rail_worktree_release_1.durableSettlementIgnoredPaths)(snap.branches),
+        onSafetyArchive: (0, transitions_1.safetyArchiveRecorder)(deps, row),
+    }));
+    const retainedWorktreeBranches = new Set(snap.worktreeIds
+        .map((wtId) => (0, rail_worktrees_store_1.getRailWorktree)(deps.db, wtId))
+        .filter((wt) => Boolean(wt && (wt.merge_state === 'needs-review' || fs.existsSync(wt.worktree_path))))
+        .map((wt) => wt.branch));
+    // 3. Delete only branches this delivery durably records as created, and only
+    //    while their live tips still equal the immutable delivered commits.
+    //    Later user/collaborator commits are retained with a cleanup warning.
+    if (deleteOwnedBranches) {
+        await (0, ownership_1.deleteOwnedBranchesIfUnchanged)(deps, row, snap, cleanupWarnings, retainedWorktreeBranches);
+    }
+    // Explicit Discard local result is also the only authority (besides proven
+    // delivery) to release a pinned orphan. A crash can occur after the atomic
+    // ref creation but before delivery_sha is written, so recover that ownership
+    // only from this delivery's exact durable final SHA or run-marker evidence.
+    if (opts.removeNeedsReview === true) {
+        let recoverySha = row.delivery_sha && evidence_1.COMMIT_SHA_RE.test(row.delivery_sha)
+            ? row.delivery_sha.toLowerCase()
+            : null;
+        if (!recoverySha && row.is_continuation === 1 &&
+            (row.status_code === 'settlement_interrupted' || row.status_code === 'recovery_unavailable')) {
+            const protection = await (0, rail_pr_recovery_git_1.inspectRecoveryCommitProtection)(deps.git, deps.project.path, row.id);
+            if (protection.kind === 'present') {
+                const durableFinalShas = [...new Set(snap.branches
+                        .map((unit) => unit.finalSha)
+                        .filter((sha) => typeof sha === 'string' && evidence_1.COMMIT_SHA_RE.test(sha))
+                        .map((sha) => sha.toLowerCase()))];
+                const runIds = [...new Set(snap.runIds.filter(Boolean))];
+                const exactDurableFinal = durableFinalShas.length === 1 && durableFinalShas[0] === protection.sha;
+                const exactRunMarker = runIds.length === 1 && await (0, rail_pr_recovery_git_1.commitCarriesRunMarker)(deps.git, deps.project.path, protection.sha, runIds[0]);
+                if (exactDurableFinal || exactRunMarker) {
+                    recoverySha = protection.sha;
+                }
+                else {
+                    cleanupWarnings.push(`recovery ref ${protection.ref}: preserved because its commit could not be proven to belong to this delivery`);
+                }
+            }
+            else if (protection.kind === 'unreadable') {
+                cleanupWarnings.push(`recovery ref ${protection.ref}: preserved because its exact commit could not be read safely`);
+            }
+        }
+        if (recoverySha && !await (0, rail_pr_recovery_git_1.releaseRecoveryCommit)(deps.git, deps.project.path, row.id, recoverySha)) {
+            cleanupWarnings.push('the delivery recovery ref changed or could not be removed; it was preserved for inspection');
+        }
+    }
+    const terminalPatch = {
+        deliveryOutcome: 'not_started',
+        statusCode: cleanupWarnings.length > 0 ? 'cleanup_incomplete' : 'discarded',
+        cleanupWarnings,
+    };
+    const conflict = preserveExternalReview || preparationFailure
+        ? (0, transitions_1.casTransition)(deps, row, 'discarded', terminalPatch)
+        : (0, transitions_1.casTransitionWithTicketEffect)(deps, row, 'discarded', terminalPatch, {
+            deliveryId: row.id,
+            ticketIds: snap.ticketIds,
+            targetStatus: 'todo',
+            // The dashboard labels discard-from-no_changes as Refine. Jira must
+            // mirror that truthful backlog return and never apply discardStatus.
+            jiraAction: row.decision === 'no_changes' ? 'refine' : 'discard',
+            prUrl: null,
+        });
+    if (conflict)
+        return conflict;
+    (0, chains_1.pauseChainsOnDiscard)(deps, row);
+    if (!preserveExternalReview && !preparationFailure)
+        (0, transitions_1.applyTerminalTicketEffect)(deps, row, 'discarded', cleanupWarnings);
+    (0, transitions_1.finalizeTransition)(deps, row.id);
+    return {
+        status: 200,
+        body: {
+            ok: true,
+            decision: 'discarded',
+            ...(cleanupWarnings.length > 0 ? { cleanupWarnings } : {}),
+            ...(preparationFailure ? { preparationFailure: true } : {}),
+            ...(preserveExternalReview ? { preservedBorrowedReview: true, preservedExternalReview: true } : {}),
+        },
+    };
+}
+async function runDismiss(deps, row) {
+    // Legality restricts dismiss to a clean/retryable continuation. Reuse the
+    // ownership-safe discard path; its external PR, head and tickets are borrowed.
+    return runDiscard(deps, row, { removeNeedsReview: false });
+}
+async function runAcknowledgeNoChanges(deps, row) {
+    const snap = (0, rail_pr_store_1.toPrDeliverySnapshot)(row);
+    const cleanupWarnings = await (0, rail_worktree_release_1.releaseRailWorktrees)({
+        db: deps.db,
+        git: deps.git,
+        repoDir: deps.project.path,
+        worktreeIds: snap.worktreeIds,
+        expectedHeadByBranch: (0, rail_worktree_release_1.durableBranchHeads)(snap.branches),
+        overlayEvidenceByBranch: (0, rail_worktree_release_1.durableOverlayCleanupEvidence)(snap.branches),
+        settlementIgnoredByBranch: (0, rail_worktree_release_1.durableSettlementIgnoredPaths)(snap.branches),
+        onSafetyArchive: (0, transitions_1.safetyArchiveRecorder)(deps, row),
+    });
+    // A fresh no-change branch is disposable only while Git still proves that it
+    // has no commits ahead of the integration base. If the user added work after
+    // settlement, preserve it and disclose the incomplete cleanup.
+    for (const branch of (0, ownership_1.ownedDeliveryBranches)(row, snap, cleanupWarnings)) {
+        if (!branch || branch === row.base_branch)
+            continue;
+        try {
+            const ahead = await deps.git.run(['rev-list', '--count', `${row.base_branch}..${branch}`], deps.project.path);
+            if (ahead.code !== 0 || Number.parseInt(ahead.stdout.trim(), 10) !== 0) {
+                cleanupWarnings.push(`branch ${branch}: retained because no-change cleanup could not prove it has zero commits ahead of ${row.base_branch}`);
+                continue;
+            }
+            const deleted = await deps.git.run(['branch', '-d', branch], deps.project.path);
+            if (deleted.code !== 0) {
+                cleanupWarnings.push(`branch ${branch}: ${(deleted.stderr.trim() || deleted.stdout.trim()).split('\n')[0] || `exit ${deleted.code}`}`);
+            }
+        }
+        catch (err) {
+            cleanupWarnings.push(`branch ${branch}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    const conflict = (0, transitions_1.casTransitionWithTicketEffect)(deps, row, 'completed', {
+        deliveryOutcome: 'no_changes',
+        statusCode: cleanupWarnings.length > 0 ? 'cleanup_incomplete' : 'no_changes',
+        cleanupWarnings,
+    }, {
+        deliveryId: row.id,
+        ticketIds: snap.ticketIds,
+        targetStatus: 'done',
+        jiraAction: 'completed',
+        prUrl: null,
+    });
+    if (conflict)
+        return conflict;
+    (0, transitions_1.applyTerminalTicketEffect)(deps, row, 'completed', cleanupWarnings);
+    (0, transitions_1.finalizeTransition)(deps, row.id);
+    return {
+        status: 200,
+        body: {
+            ok: true,
+            decision: 'completed',
+            noChanges: true,
+            ...(cleanupWarnings.length > 0 ? { cleanupWarnings } : {}),
+        },
+    };
+}

package/server/dist/modules/delivery/adapters/decisions/dispatch.js

@@ -0,0 +1,107 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executePrDecision = executePrDecision;
+const __1 = require("../..");
+const rail_pr_store_1 = require("../../runtime/rail-pr-store");
+const ids_1 = require("../../../../ids");
+const transitions_1 = require("./transitions");
+const create_1 = require("./create");
+const publish_1 = require("./publish");
+const discard_1 = require("./discard");
+const merge_local_1 = require("./merge-local");
+const recovery_1 = require("./recovery");
+async function executePrDecision(deps, input) {
+    const row = (0, rail_pr_store_1.getPrDelivery)(deps.db, input.prDeliveryId);
+    if (!row)
+        return { status: 404, body: { error: 'Unknown prDeliveryId' } };
+    if (row.parent_delivery_id && deps.repositoryChildOf !== row.parent_delivery_id)
+        return { status: 409, body: { error: 'repository_delivery_requires_parent', parentDeliveryId: row.parent_delivery_id } };
+    // A manifest alone does not make a repository GROUP: a launch that failed
+    // before allocating a single repository delivery persists the parent with
+    // its manifest and zero children (observed: `git worktree add` refused
+    // because the PR branch was checked out in the main clone). Routing that
+    // parent into the group path 404'd on "no repositories" — which the UI read
+    // as "already resolved" — and left the rail pinned at pending_decision.
+    if (!row.parent_delivery_id && row.execution_manifest && (0, rail_pr_store_1.hasRepositoryDeliveries)(deps.db, row.id)) {
+        const { executeRepositoryGroupDecision } = await Promise.resolve().then(() => __importStar(require('../../runtime/multi-repo-delivery')));
+        return executeRepositoryGroupDecision(deps, input);
+    }
+    // Compare-and-set pre-check: the caller decided against a snapshot — if the
+    // row moved on (the other surface answered first), it must reconcile, not act.
+    if (row.decision !== input.expectedDecision)
+        return (0, transitions_1.staleDecision)(row.decision);
+    if (!(0, __1.actionAllowed)(input.action, row))
+        return (0, transitions_1.illegalAction)(row.decision);
+    // Claim before any git/GitHub/cleanup/ticket effect. The visible decision is
+    // unchanged while the winner works, but a second surface cannot start.
+    const operationToken = (0, ids_1.newId)();
+    if (!(0, rail_pr_store_1.claimPrDeliveryOperation)(deps.db, row.id, row.decision, input.action, operationToken)) {
+        const current = (0, rail_pr_store_1.getPrDelivery)(deps.db, row.id);
+        if (!current || current.decision !== input.expectedDecision) {
+            return (0, transitions_1.staleDecision)(current?.decision ?? row.decision);
+        }
+        return {
+            status: 409,
+            body: { error: 'operation_in_progress', current: current.decision, operation: current.operation },
+        };
+    }
+    const claimedRow = (0, rail_pr_store_1.getPrDelivery)(deps.db, row.id);
+    if (!claimedRow || claimedRow.operation_token !== operationToken) {
+        return { status: 409, body: { error: 'operation_in_progress', current: claimedRow?.decision ?? row.decision } };
+    }
+    try {
+        switch (input.action) {
+            case 'create-pr': return await (0, create_1.runCreatePr)(deps, claimedRow);
+            case 'publish': return await (0, publish_1.runPublish)(deps, claimedRow);
+            case 'discard': return await (0, discard_1.runDiscard)(deps, claimedRow);
+            case 'dismiss': return await (0, discard_1.runDismiss)(deps, claimedRow);
+            case 'poll-merge': return await (0, publish_1.runPollMerge)(deps, claimedRow);
+            case 'reopen': return await (0, publish_1.runReopen)(deps, claimedRow);
+            case 'merge-local': return await (0, merge_local_1.runMergeLocal)(deps, claimedRow);
+            case 'acknowledge-no-changes': return await (0, discard_1.runAcknowledgeNoChanges)(deps, claimedRow);
+            case 'recover-and-retry': return await (0, recovery_1.runRecoverAndRetry)(deps, claimedRow);
+        }
+        return (0, transitions_1.illegalAction)(row.decision);
+    }
+    finally {
+        try {
+            (0, rail_pr_store_1.releasePrDeliveryOperation)(deps.db, row.id, operationToken);
+        }
+        catch { /* durable state remains authoritative */ }
+        if (transitions_1.deferredFinalizations.delete(row.id))
+            (0, transitions_1.finalizeTransition)(deps, row.id);
+    }
+}