specrails-desktop 2.55.0 → 2.56.0

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

@@ -0,0 +1,109 @@
+"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.parsePrNumber = parsePrNumber;
+exports.batchWorktreeRoot = batchWorktreeRoot;
+exports.loadPrTicketData = loadPrTicketData;
+exports.resolveTicketFile = resolveTicketFile;
+exports.mergeLocalTargetBranch = mergeLocalTargetBranch;
+const path = __importStar(require("path"));
+const artifact_registry_1 = require("../../../../artifact-registry");
+const jira_db_1 = require("../../../../jira/jira-db");
+const ticket_store_1 = require("../../../specs/runtime/ticket-store");
+const workspace_resolution_1 = require("../../../../workspace-resolution");
+const milestone_chain_store_1 = require("../../../builder/runtime/milestone-chain-store");
+function parsePrNumber(prUrl) {
+    const m = /\/pull\/(\d+)/.exec(prUrl);
+    return m ? parseInt(m[1], 10) : null;
+}
+function batchWorktreeRoot(slug) {
+    // Mirrors rail-isolated-launch's worktreesRoot — derivable, never stored.
+    return path.join((0, artifact_registry_1.resolveHome)(), '.specrails', 'projects', slug, 'worktrees');
+}
+/**
+ * Load the PR's ticket data (title/labels/description) from the ticket store,
+ * with the Jira key resolved PER TICKET: the authoritative `jira_links` row
+ * prevails over the ticket's `jira_key` field (JIRA ALWAYS PREVAILS), no HTTP.
+ * Tolerant of a missing/corrupt store or link table — degrades to bare local
+ * ids, never throws, never blocks PR creation.
+ */
+function loadPrTicketData(deps, ticketIds) {
+    let tickets = {};
+    try {
+        tickets = (0, ticket_store_1.readStore)(resolveTicketFile(deps)).tickets;
+    }
+    catch {
+        /* tolerated — the PR falls back to bare ticket refs */
+    }
+    return ticketIds.map((id) => {
+        const t = tickets[String(id)];
+        let jiraKey = t?.jira_key ?? null;
+        try {
+            const link = (0, jira_db_1.getLinkByLocalId)(deps.db, id);
+            if (link && !link.tombstoned && link.jiraKey)
+                jiraKey = link.jiraKey;
+        }
+        catch {
+            /* tolerated — fall back to the ticket field */
+        }
+        return {
+            ticketId: id,
+            title: t?.title ?? null,
+            labels: t?.labels ?? null,
+            description: t?.description ?? null,
+            jiraKey,
+        };
+    });
+}
+function resolveTicketFile(deps) {
+    if (deps.ticketFile)
+        return deps.ticketFile;
+    const exec = (0, workspace_resolution_1.resolveProjectExecution)({ slug: deps.project.slug, path: deps.project.path });
+    return exec.relocated ? exec.ticketsPath : (0, ticket_store_1.resolveTicketStoragePath)(deps.project.path);
+}
+/** Local-integration target: a chain-launched (stacked) delivery integrates
+ *  into the chain's integration branch, never into its feature base. */
+function mergeLocalTargetBranch(deps, row) {
+    if (deps.repositoryChildOf)
+        return deps.repositoryIntegrationBranch ?? row.base_branch;
+    try {
+        for (const chain of (0, milestone_chain_store_1.listChainsTouchingDelivery)(deps.db, row.id)) {
+            if (chain.integration_branch)
+                return chain.integration_branch;
+        }
+    }
+    catch { /* fall through */ }
+    return row.base_branch;
+}

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);
+    });
+}