specrails-desktop 2.55.0 → 2.55.1

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

@@ -0,0 +1,260 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergedEvidenceDetail = mergedEvidenceDetail;
+exports.rerouteFromStalePr = rerouteFromStalePr;
+exports.settleObservedExistingPr = settleObservedExistingPr;
+exports.settleObservedClosedPr = settleObservedClosedPr;
+exports.persistRetryablePrObservationFailure = persistRetryablePrObservationFailure;
+exports.persistMovedPrHead = persistMovedPrHead;
+exports.persistRecoveryBlocked = persistRecoveryBlocked;
+exports.persistProtectedRecoveryRetry = persistProtectedRecoveryRetry;
+exports.settleMergedPr = settleMergedPr;
+const rail_worktree_release_1 = require("../../runtime/rail-worktree-release");
+const rail_pr_store_1 = require("../../runtime/rail-pr-store");
+const ownership_1 = require("./ownership");
+const transitions_1 = require("./transitions");
+const evidence_1 = require("./evidence");
+const chains_1 = require("./chains");
+function mergedEvidenceDetail(observation) {
+    return observation.includesExpectedSha === null
+        ? 'GitHub did not return enough commit evidence to prove the previous PR included the verified implementation commit'
+        : 'the previous PR merged without the verified implementation commit';
+}
+async function rerouteFromStalePr(deps, row, detail, exactWasPushed) {
+    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: (0, ownership_1.releasableWorktreeIds)(deps, snap),
+        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 partial = row.implementation_outcome === 'partially_succeeded';
+    const preserved = row.delivery_sha ? 'the preserved exact commit' : 'the preserved recorded branch';
+    const conflict = (0, transitions_1.casTransition)(deps, row, 'on_review', {
+        prUrl: null,
+        prNumber: null,
+        prState: exactWasPushed ? 'pushed' : 'local-only',
+        deliveryOutcome: partial ? 'partial' : 'ready',
+        statusCode: cleanupWarnings.length > 0 ? 'cleanup_incomplete' : partial ? 'partial_success' : 'ready_for_review',
+        statusDetail: `${detail}; create a new draft PR from ${preserved}`,
+        cleanupWarnings,
+        // The replacement PR belongs to this generation. Per-unit branch ownership
+        // remains unchanged so a borrowed/pre-existing ref is still never deleted.
+        isContinuation: false,
+    });
+    if (conflict)
+        return conflict;
+    const after = (0, transitions_1.finalizeTransition)(deps, row.id);
+    return {
+        status: 200,
+        body: {
+            ok: true,
+            decision: 'on_review',
+            prUrl: null,
+            prState: after?.prState ?? (exactWasPushed ? 'pushed' : 'local-only'),
+            rerouted: true,
+            detail,
+        },
+    };
+}
+async function settleObservedExistingPr(deps, row, observation, pushed) {
+    const next = observation.state === 'MERGED' || observation.isDraft === false ? 'pr_ready' : 'pr_draft';
+    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: (0, ownership_1.releasableWorktreeIds)(deps, snap),
+        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 conflict = (0, transitions_1.casTransition)(deps, row, next, {
+        prState: 'pr-created',
+        deliveryOutcome: 'delivered',
+        statusCode: cleanupWarnings.length > 0 ? 'cleanup_incomplete' : next === 'pr_ready' ? 'pr_ready' : 'existing_pr_updated',
+        statusDetail: null,
+        cleanupWarnings,
+    });
+    if (conflict)
+        return conflict;
+    await (0, evidence_1.releaseDeliveredRecoveryLineage)(deps, row, row.delivery_sha);
+    const after = (0, transitions_1.finalizeTransition)(deps, row.id);
+    return {
+        status: 200,
+        body: {
+            ok: true,
+            decision: next,
+            prUrl: after?.prUrl ?? row.pr_url,
+            prState: 'pr-created',
+            deliveryVerified: true,
+            verifiedSha: row.delivery_sha,
+            remoteHeadSha: observation.headRefOid,
+            pushed,
+        },
+    };
+}
+async function settleObservedClosedPr(deps, row, observation) {
+    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: (0, ownership_1.releasableWorktreeIds)(deps, snap),
+        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 conflict = (0, transitions_1.casTransition)(deps, row, 'pr_closed', {
+        prState: 'pr-created',
+        deliveryOutcome: 'delivered',
+        statusCode: cleanupWarnings.length > 0 ? 'cleanup_incomplete' : 'pr_closed',
+        statusDetail: null,
+        cleanupWarnings,
+    });
+    if (conflict)
+        return conflict;
+    await (0, evidence_1.releaseDeliveredRecoveryLineage)(deps, row, row.delivery_sha);
+    const after = (0, transitions_1.finalizeTransition)(deps, row.id);
+    return {
+        status: 200,
+        body: {
+            ok: true,
+            decision: 'pr_closed',
+            closed: true,
+            merged: false,
+            prUrl: after?.prUrl ?? row.pr_url,
+            prState: 'pr-created',
+            deliveryVerified: true,
+            verifiedSha: row.delivery_sha,
+            remoteHeadSha: observation.headRefOid,
+            pushed: false,
+        },
+    };
+}
+function persistRetryablePrObservationFailure(deps, row, detail) {
+    const conflict = (0, transitions_1.casTransition)(deps, row, 'pr_failed', {
+        deliveryOutcome: 'retryable_failure',
+        statusCode: 'push_failed',
+        statusDetail: detail,
+    });
+    if (conflict)
+        return conflict;
+    (0, transitions_1.finalizeTransition)(deps, row.id);
+    return { status: 200, body: { ok: true, decision: 'pr_failed', prUrl: row.pr_url, detail } };
+}
+function persistMovedPrHead(deps, row, detail) {
+    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', prUrl: row.pr_url, detail } };
+}
+function persistRecoveryBlocked(deps, row, detail, deliverySha) {
+    const conflict = (0, transitions_1.casTransition)(deps, row, 'pr_failed', {
+        deliveryOutcome: 'blocked',
+        statusCode: 'recovery_unavailable',
+        statusDetail: detail,
+        ...(deliverySha !== undefined ? { deliverySha } : {}),
+        isContinuation: true,
+    });
+    if (conflict)
+        return conflict;
+    (0, transitions_1.finalizeTransition)(deps, row.id);
+    return {
+        status: 200,
+        body: {
+            ok: true,
+            decision: 'pr_failed',
+            prUrl: row.pr_url,
+            recoveryUnavailable: true,
+            detail,
+        },
+    };
+}
+function persistProtectedRecoveryRetry(deps, row, snap, matchingUnitIndexes, runId, candidateSha, detail) {
+    const recoveredIndexes = new Set(matchingUnitIndexes);
+    const recoveredBranches = snap.branches.map((unit, index) => recoveredIndexes.has(index)
+        ? {
+            ...unit,
+            runId,
+            branch: row.branch,
+            succeeded: true,
+            implementationOutcome: 'succeeded',
+            deliveryOutcome: 'ready',
+            finalSha: candidateSha,
+            changed: unit.changed ?? (unit.initialSha ? unit.initialSha.toLowerCase() !== candidateSha.toLowerCase() : true),
+            failureCode: null,
+            branchOwnership: 'borrowed-pr',
+        }
+        : unit);
+    const conflict = (0, transitions_1.casTransition)(deps, row, 'pr_failed', {
+        branches: recoveredBranches,
+        deliverySha: candidateSha,
+        deliveryOutcome: 'retryable_failure',
+        statusCode: 'settlement_interrupted',
+        statusDetail: detail,
+        isContinuation: true,
+    });
+    if (conflict)
+        return conflict;
+    (0, transitions_1.finalizeTransition)(deps, row.id);
+    return {
+        status: 200,
+        body: {
+            ok: true,
+            decision: 'pr_failed',
+            prUrl: row.pr_url,
+            recovered: true,
+            detail,
+        },
+    };
+}
+async function settleMergedPr(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: (0, ownership_1.releasableWorktreeIds)(deps, snap), state: 'merged',
+        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),
+    });
+    await (0, ownership_1.deleteOwnedBranchesIfUnchanged)(deps, row, snap, cleanupWarnings);
+    const conflict = (0, transitions_1.casTransitionWithTicketEffect)(deps, row, 'merged', {
+        deliveryOutcome: 'delivered',
+        statusCode: cleanupWarnings.length > 0 ? 'cleanup_incomplete' : 'merged',
+        statusDetail: null,
+        cleanupWarnings,
+    }, {
+        deliveryId: row.id,
+        ticketIds: snap.ticketIds,
+        targetStatus: 'done',
+        jiraAction: 'merged',
+        prUrl: row.pr_url,
+    });
+    if (conflict)
+        return conflict;
+    await (0, evidence_1.releaseDeliveredRecoveryLineage)(deps, row, row.delivery_sha);
+    (0, transitions_1.applyTerminalTicketEffect)(deps, row, 'merged', cleanupWarnings);
+    (0, transitions_1.finalizeTransition)(deps, row.id);
+    await (0, chains_1.sweepMergedChainAncestors)(deps, row);
+    return {
+        status: 200,
+        body: {
+            ok: true,
+            decision: 'merged',
+            merged: true,
+            prUrl: row.pr_url,
+            ...(row.delivery_sha ? {
+                deliveryVerified: true,
+                verifiedSha: row.delivery_sha,
+                pushed: false,
+            } : {}),
+        },
+    };
+}

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

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unitWasDelivered = unitWasDelivered;
+exports.ownedDeliveryBranches = ownedDeliveryBranches;
+exports.immutableHeadForOwnedBranch = immutableHeadForOwnedBranch;
+exports.deleteOwnedBranchesIfUnchanged = deleteOwnedBranchesIfUnchanged;
+exports.releasableWorktreeIds = releasableWorktreeIds;
+const rail_worktrees_store_1 = require("../../runtime/rail-worktrees-store");
+const evidence_1 = require("./evidence");
+/** A legacy record's `succeeded` bit meant delivery eligibility. New records
+ * state that eligibility directly; blocked/no-change units are never swept as
+ * a side effect of delivering another unit in the same batch. */
+function unitWasDelivered(unit) {
+    return unit.deliveryOutcome === undefined ? unit.succeeded : unit.deliveryOutcome === 'ready';
+}
+/** Branch deletion is ownership-based, never name-derived. Legacy rows without
+ * ownership evidence degrade to preservation. A multi-unit assembled head is
+ * owned when it is distinct from every recorded unit branch. */
+function ownedDeliveryBranches(row, snap, cleanupWarnings) {
+    const unknownOwnership = row.is_continuation !== 1
+        ? snap.branches.filter((unit) => unitWasDelivered(unit) && unit.branchOwnership === undefined)
+        : [];
+    if (cleanupWarnings && unknownOwnership.length > 0) {
+        cleanupWarnings.push(`branch cleanup preserved ${unknownOwnership.length} legacy ${unknownOwnership.length === 1 ? 'branch' : 'branches'} because ownership was not recorded`);
+    }
+    const owned = new Set(snap.branches
+        .filter((unit) => unit.branchOwnership === 'created' && unitWasDelivered(unit))
+        .map((unit) => unit.branch));
+    if (row.is_continuation !== 1 && snap.branches.length > 1 && row.branch &&
+        !snap.branches.some((unit) => unit.branch === row.branch))
+        owned.add(row.branch);
+    return owned;
+}
+function immutableHeadForOwnedBranch(row, snap, branch) {
+    if (branch === row.branch && row.delivery_sha && evidence_1.COMMIT_SHA_RE.test(row.delivery_sha)) {
+        return row.delivery_sha.toLowerCase();
+    }
+    const unitHeads = new Set(snap.branches
+        .filter((unit) => unitWasDelivered(unit) && unit.branch === branch && unit.finalSha && evidence_1.COMMIT_SHA_RE.test(unit.finalSha))
+        .map((unit) => unit.finalSha.toLowerCase()));
+    return unitHeads.size === 1 ? [...unitHeads][0] : null;
+}
+async function deleteOwnedBranchesIfUnchanged(deps, row, snap, cleanupWarnings, protectedBranches = new Set()) {
+    for (const branch of ownedDeliveryBranches(row, snap, cleanupWarnings)) {
+        if (!branch || branch === row.base_branch)
+            continue;
+        // A failed release leaves the linked worktree mounted for inspection. Do
+        // not even attempt to delete its checked-out branch: preserving the files
+        // while erasing their durable ref would make the recovery story depend on
+        // Git's incidental checked-out-branch rejection.
+        if (protectedBranches.has(branch)) {
+            cleanupWarnings.push(`branch ${branch}: retained with its worktree for inspection`);
+            continue;
+        }
+        try {
+            const expectedHead = immutableHeadForOwnedBranch(row, snap, branch);
+            if (!expectedHead) {
+                cleanupWarnings.push(`branch ${branch}: retained because no unambiguous immutable delivered HEAD was recorded`);
+                continue;
+            }
+            const observed = await deps.git.run(['rev-parse', '--verify', `refs/heads/${branch}`], deps.project.path);
+            const observedHead = observed.code === 0 ? observed.stdout.trim().toLowerCase() : '';
+            if (!evidence_1.COMMIT_SHA_RE.test(observedHead) || observedHead !== expectedHead) {
+                cleanupWarnings.push(`branch ${branch}: retained because its current tip no longer matches delivered HEAD ${expectedHead.slice(0, 12)}`);
+                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)}`);
+        }
+    }
+}
+function releasableWorktreeIds(deps, snap) {
+    const preservedBranches = new Set(snap.branches.filter((unit) => !unitWasDelivered(unit)).map((unit) => unit.branch));
+    return snap.worktreeIds.filter((id) => {
+        const wt = (0, rail_worktrees_store_1.getRailWorktree)(deps.db, id);
+        return !wt || !preservedBranches.has(wt.branch);
+    });
+}

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

@@ -0,0 +1,242 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPublish = runPublish;
+exports.runPollMerge = runPollMerge;
+exports.runReopen = runReopen;
+const pr_lifecycle_1 = require("../../runtime/pr-lifecycle");
+const observations_1 = require("./observations");
+const transitions_1 = require("./transitions");
+async function runPublish(deps, row) {
+    if (!row.delivery_sha || !row.branch) {
+        return (0, observations_1.persistMovedPrHead)(deps, row, 'the draft PR has no immutable delivery SHA/head identity; refusing to mutate unverifiable review state');
+    }
+    const beforePublish = await (0, pr_lifecycle_1.observePrLifecycle)(deps.exec, deps.project.path, row.pr_url, row.delivery_sha);
+    if (!beforePublish.ok) {
+        return { status: 502, body: { error: 'gh_failed', detail: beforePublish.detail } };
+    }
+    if (!(0, pr_lifecycle_1.matchesRecordedPrIdentity)(beforePublish, row.branch, row.base_branch)) {
+        return (0, observations_1.rerouteFromStalePr)(deps, row, `the recorded PR is ${beforePublish.state.toLowerCase()} but no longer matches its original head/base identity`, beforePublish.includesExpectedSha === true);
+    }
+    if (beforePublish.state === 'MERGED') {
+        return beforePublish.includesExpectedSha === true
+            ? (0, observations_1.settleMergedPr)(deps, row)
+            : (0, observations_1.rerouteFromStalePr)(deps, row, (0, observations_1.mergedEvidenceDetail)(beforePublish), false);
+    }
+    if (beforePublish.state === 'CLOSED') {
+        return beforePublish.includesExpectedSha === true
+            ? (0, observations_1.settleObservedClosedPr)(deps, row, beforePublish)
+            : (0, observations_1.rerouteFromStalePr)(deps, row, 'the draft PR closed without the verified implementation commit', false);
+    }
+    if (beforePublish.includesExpectedSha !== true) {
+        return (0, observations_1.persistRetryablePrObservationFailure)(deps, row, 'the draft PR no longer exposes the verified implementation commit; Retry push is available and will use the preserved exact SHA');
+    }
+    if (beforePublish.isDraft === false) {
+        return (0, observations_1.settleObservedExistingPr)(deps, row, beforePublish, false);
+    }
+    let r;
+    try {
+        r = await deps.exec.run('gh', ['pr', 'ready', row.pr_url], deps.project.path);
+    }
+    catch (err) {
+        r = { code: 1, stdout: '', stderr: err instanceof Error ? err.message : String(err) };
+    }
+    // `gh pr ready` is externally mutating and may return an ambiguous error.
+    // Re-observe exact remote truth in every case before changing the ledger.
+    const afterPublish = await (0, pr_lifecycle_1.observePrLifecycle)(deps.exec, deps.project.path, row.pr_url, row.delivery_sha);
+    if (!afterPublish.ok) {
+        if (r.code !== 0)
+            return (0, transitions_1.ghFailed)(r);
+        return { status: 502, body: { error: 'gh_failed', detail: `PR readiness could not be verified: ${afterPublish.detail}` } };
+    }
+    if (!(0, pr_lifecycle_1.matchesRecordedPrIdentity)(afterPublish, row.branch, row.base_branch)) {
+        return (0, observations_1.rerouteFromStalePr)(deps, row, `the PR identity changed while publishing it for review (${afterPublish.state.toLowerCase()})`, afterPublish.includesExpectedSha === true);
+    }
+    if (afterPublish.state === 'MERGED') {
+        return afterPublish.includesExpectedSha === true
+            ? (0, observations_1.settleMergedPr)(deps, row)
+            : (0, observations_1.rerouteFromStalePr)(deps, row, (0, observations_1.mergedEvidenceDetail)(afterPublish), false);
+    }
+    if (afterPublish.state === 'CLOSED') {
+        return afterPublish.includesExpectedSha === true
+            ? (0, observations_1.settleObservedClosedPr)(deps, row, afterPublish)
+            : (0, observations_1.rerouteFromStalePr)(deps, row, 'the PR closed without the verified implementation commit while being published', false);
+    }
+    if (afterPublish.includesExpectedSha !== true) {
+        return (0, observations_1.persistRetryablePrObservationFailure)(deps, row, 'the PR no longer exposes the verified implementation commit after publishing; Retry push is available');
+    }
+    if (afterPublish.isDraft) {
+        if (r.code !== 0)
+            return (0, transitions_1.ghFailed)(r);
+        return { status: 502, body: { error: 'gh_failed', detail: 'PR remained a draft after publishing' } };
+    }
+    return (0, observations_1.settleObservedExistingPr)(deps, row, afterPublish, false);
+}
+async function runPollMerge(deps, row) {
+    const observed = await (0, pr_lifecycle_1.observePrLifecycle)(deps.exec, deps.project.path, row.pr_url, row.delivery_sha);
+    if (!observed.ok)
+        return { status: 502, body: { error: 'gh_failed', detail: observed.detail } };
+    const { state, isDraft } = observed;
+    if (!row.branch) {
+        return (0, observations_1.persistMovedPrHead)(deps, row, `the ${state.toLowerCase()} PR has no recorded delivery branch; refusing to infer recoverable work`);
+    }
+    if (!row.delivery_sha) {
+        // A legacy OPEN row cannot be retried without an immutable object. Once the
+        // attached PR is terminal, however, keeping that stale URL would strand the
+        // only recorded branch behind Discard. Detach it so Create PR can perform
+        // the existing one-time legacy ref capture, without claiming any delivery.
+        if (state === 'CLOSED' || state === 'MERGED') {
+            return (0, observations_1.rerouteFromStalePr)(deps, row, `the previous PR is ${state.toLowerCase()} and this legacy delivery has no persisted verified SHA`, false);
+        }
+        return (0, observations_1.persistMovedPrHead)(deps, row, 'the open PR has no persisted verified delivery SHA; refusing to infer delivery from a mutable branch');
+    }
+    if (!(0, pr_lifecycle_1.matchesRecordedPrIdentity)(observed, row.branch, row.base_branch)) {
+        return (0, observations_1.rerouteFromStalePr)(deps, row, `the recorded PR is ${state.toLowerCase()} but no longer matches its original head/base identity`, observed.includesExpectedSha === true);
+    }
+    if (state === 'CLOSED') {
+        if (observed.includesExpectedSha !== true) {
+            return (0, observations_1.rerouteFromStalePr)(deps, row, 'the previous PR closed without the verified implementation commit', false);
+        }
+        return (0, observations_1.settleObservedClosedPr)(deps, row, observed);
+    }
+    if (state === 'OPEN') {
+        if (observed.includesExpectedSha !== true) {
+            const detail = 'the open PR no longer exposes the verified implementation commit; Retry push is available and will use the preserved exact SHA';
+            const result = (0, observations_1.persistRetryablePrObservationFailure)(deps, row, detail);
+            return {
+                ...result,
+                body: {
+                    ...result.body,
+                    deliveryVerified: false,
+                    verifiedSha: row.delivery_sha,
+                    remoteHeadSha: observed.headRefOid,
+                },
+            };
+        }
+        // A successful reopen can be observed even if the explicit action lost its
+        // follow-up `gh view` response. Polling heals pr_closed from remote truth.
+        if (row.decision === 'pr_closed') {
+            const next = isDraft ? 'pr_draft' : 'pr_ready';
+            const conflict = (0, transitions_1.casTransition)(deps, row, next, {
+                deliveryOutcome: 'delivered', statusCode: isDraft ? 'pr_draft_ready' : 'pr_ready',
+            });
+            if (conflict)
+                return conflict;
+            (0, transitions_1.finalizeTransition)(deps, row.id);
+            return {
+                status: 200,
+                body: {
+                    ok: true,
+                    decision: next,
+                    merged: false,
+                    reopened: true,
+                    prUrl: row.pr_url,
+                    deliveryVerified: true,
+                    verifiedSha: row.delivery_sha,
+                    remoteHeadSha: observed.headRefOid,
+                    pushed: false,
+                },
+            };
+        }
+        return {
+            status: 200,
+            body: {
+                ok: true,
+                decision: row.decision,
+                merged: false,
+                deliveryVerified: true,
+                verifiedSha: row.delivery_sha,
+                remoteHeadSha: observed.headRefOid,
+                pushed: false,
+            },
+        };
+    }
+    if (state !== 'MERGED') {
+        return { status: 502, body: { error: 'gh_failed', detail: `unexpected PR state: ${state}` } };
+    }
+    // A PR can merge just before a continuation push; GitHub may then accept a
+    // later update to the head branch even though that object was never part of
+    // the merge. Never move tickets to Done from state=MERGED alone.
+    if (observed.includesExpectedSha !== true) {
+        return (0, observations_1.rerouteFromStalePr)(deps, row, (0, observations_1.mergedEvidenceDetail)(observed), false);
+    }
+    return (0, observations_1.settleMergedPr)(deps, row);
+}
+async function runReopen(deps, row) {
+    if (!row.delivery_sha || !row.branch) {
+        return (0, observations_1.rerouteFromStalePr)(deps, row, 'the closed PR cannot be reopened safely because its immutable delivery SHA/head identity is unavailable', false);
+    }
+    const beforeReopen = await (0, pr_lifecycle_1.observePrLifecycle)(deps.exec, deps.project.path, row.pr_url, row.delivery_sha);
+    if (!beforeReopen.ok) {
+        return { status: 502, body: { error: 'gh_failed', detail: beforeReopen.detail } };
+    }
+    if (!(0, pr_lifecycle_1.matchesRecordedPrIdentity)(beforeReopen, row.branch, row.base_branch) ||
+        beforeReopen.includesExpectedSha !== true) {
+        return (0, observations_1.rerouteFromStalePr)(deps, row, 'the closed PR no longer proves the recorded head/base and verified implementation commit', false);
+    }
+    if (beforeReopen.state === 'MERGED')
+        return (0, observations_1.settleMergedPr)(deps, row);
+    if (beforeReopen.state === 'OPEN') {
+        const next = beforeReopen.isDraft ? 'pr_draft' : 'pr_ready';
+        const conflict = (0, transitions_1.casTransition)(deps, row, next, {
+            deliveryOutcome: 'delivered', statusCode: beforeReopen.isDraft ? 'pr_draft_ready' : 'pr_ready',
+            statusDetail: null,
+        });
+        if (conflict)
+            return conflict;
+        (0, transitions_1.finalizeTransition)(deps, row.id);
+        return {
+            status: 200,
+            body: {
+                ok: true, decision: next, reopened: true, prUrl: row.pr_url,
+                deliveryVerified: true, verifiedSha: row.delivery_sha,
+                remoteHeadSha: beforeReopen.headRefOid, pushed: false,
+            },
+        };
+    }
+    let reopened;
+    try {
+        reopened = await deps.exec.run('gh', ['pr', 'reopen', row.pr_url], deps.project.path);
+    }
+    catch (err) {
+        reopened = { code: 1, stdout: '', stderr: err instanceof Error ? err.message : String(err) };
+    }
+    const observed = await (0, pr_lifecycle_1.observePrLifecycle)(deps.exec, deps.project.path, row.pr_url, row.delivery_sha);
+    if (!observed.ok) {
+        if (reopened.code !== 0)
+            return (0, transitions_1.ghFailed)(reopened);
+        return { status: 502, body: { error: 'gh_failed', detail: observed.detail } };
+    }
+    const identityMatches = (0, pr_lifecycle_1.matchesRecordedPrIdentity)(observed, row.branch, row.base_branch);
+    if (observed.state === 'MERGED') {
+        if (identityMatches && observed.includesExpectedSha === true)
+            return (0, observations_1.settleMergedPr)(deps, row);
+        return (0, observations_1.rerouteFromStalePr)(deps, row, identityMatches ? (0, observations_1.mergedEvidenceDetail)(observed) : 'the PR identity changed while it was being reopened', false);
+    }
+    if (observed.state === 'CLOSED') {
+        if (!identityMatches || observed.includesExpectedSha !== true) {
+            return (0, observations_1.rerouteFromStalePr)(deps, row, 'the PR remained closed without proving the recorded head/base and verified implementation commit', false);
+        }
+        if (reopened.code !== 0)
+            return (0, transitions_1.ghFailed)(reopened);
+        return { status: 502, body: { error: 'gh_failed', detail: 'PR remained closed after reopen' } };
+    }
+    if (!identityMatches || observed.includesExpectedSha !== true) {
+        return (0, observations_1.rerouteFromStalePr)(deps, row, 'the reopened PR no longer proves the recorded head/base and verified implementation commit', true);
+    }
+    const next = observed.isDraft ? 'pr_draft' : 'pr_ready';
+    const conflict = (0, transitions_1.casTransition)(deps, row, next, {
+        deliveryOutcome: 'delivered', statusCode: observed.isDraft ? 'pr_draft_ready' : 'pr_ready',
+        statusDetail: null,
+    });
+    if (conflict)
+        return conflict;
+    (0, transitions_1.finalizeTransition)(deps, row.id);
+    return {
+        status: 200,
+        body: {
+            ok: true, decision: next, reopened: true, prUrl: row.pr_url,
+            deliveryVerified: true, verifiedSha: row.delivery_sha,
+            remoteHeadSha: observed.headRefOid, pushed: false,
+        },
+    };
+}