specrails-desktop 2.55.0 → 2.56.0

package/server/dist/{explore-smash.js → modules/conversations/runtime/explore-smash.js}

@@ -5,7 +5,7 @@
  * Decomposes a committed ticket (with Contract Layer) into 3–8 ordered
  * child tickets. This module contains only the byte-stable system prompt,
  * the output schema, and the parser/validator. The spawn lifecycle and
- * store mutation live in `server/smash-runner.ts`.
+ * store mutation live in `server/modules/specs/runtime/smash-runner.ts`.
  *
  * See openspec/changes/add-specs-smash.
  */

package/server/dist/{explore-stdin-session.js → modules/conversations/runtime/explore-stdin-session.js}

@@ -22,7 +22,7 @@ exports.isExplorePersistentStdinEnabled = isExplorePersistentStdinEnabled;
 exports.frameStreamJsonUserMessage = frameStreamJsonUserMessage;
 const node_readline_1 = require("node:readline");
 const tree_kill_1 = __importDefault(require("tree-kill"));
-const cli_prompt_1 = require("./util/cli-prompt");
+const cli_prompt_1 = require("../../../util/cli-prompt");
 /**
  * Persistent-stdin Explore is opt-in. Default OFF — set
  * `SPECRAILS_EXPLORE_PERSISTENT_STDIN=1` to enable. Any other value (or unset)

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

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SWEEPABLE_DECISIONS = void 0;
+exports.sweepMergedChainAncestors = sweepMergedChainAncestors;
+exports.pauseChainsOnDiscard = pauseChainsOnDiscard;
+const rail_worktree_release_1 = require("../../runtime/rail-worktree-release");
+const ids_1 = require("../../../../ids");
+const milestone_chain_store_1 = require("../../../builder/runtime/milestone-chain-store");
+const rail_pr_store_1 = require("../../runtime/rail-pr-store");
+const evidence_1 = require("./evidence");
+const ownership_1 = require("./ownership");
+const transitions_1 = require("./transitions");
+// ─── Milestone chain hooks (premium-milestone-progress D4) ───────────────────
+/** Decisions a stacked sibling can sit at while its head is already merged. */
+exports.SWEEPABLE_DECISIONS = new Set(['on_review', 'pr_draft', 'pr_ready', 'pr_closed']);
+/**
+ * Merging a STACKED delivery also lands every earlier chunk it was built on.
+ * Walk the chain(s) this delivery belongs to and settle each still-undecided
+ * sibling whose delivered head commit is PROVABLY an ancestor of the chain's
+ * integration branch (`git merge-base --is-ancestor`) as `merged` — the same
+ * CAS + ticket effect (`done`) + Jira hook a direct merge runs. Chain-local by
+ * design; siblings whose head is not an ancestor are left untouched. Returns
+ * the swept delivery ids. Never throws.
+ */
+async function sweepMergedChainAncestors(deps, mergedRow) {
+    const swept = [];
+    if (deps.repositoryChildOf)
+        return swept;
+    let chains;
+    try {
+        chains = (0, milestone_chain_store_1.listChainsTouchingDelivery)(deps.db, mergedRow.id);
+    }
+    catch {
+        return swept;
+    }
+    for (const chain of chains) {
+        const integration = chain.integration_branch;
+        if (!integration)
+            continue;
+        for (const entry of (0, milestone_chain_store_1.parseLaunched)(chain)) {
+            if (!entry.deliveryId || entry.deliveryId === mergedRow.id || swept.includes(entry.deliveryId))
+                continue;
+            const other = (0, rail_pr_store_1.getPrDelivery)(deps.db, entry.deliveryId);
+            if (!other || (0, rail_pr_store_1.isTerminalPrDecision)(other.decision) || !exports.SWEEPABLE_DECISIONS.has(other.decision))
+                continue;
+            const snap = (0, rail_pr_store_1.toPrDeliverySnapshot)(other);
+            // An assembled delivery SHA proves the whole chunk. Without that head,
+            // every unit needs its own immutable proof; accepting just the first
+            // ancestor could mark unmerged tickets done and delete their branches.
+            const requiredShas = snap.deliverySha ? [snap.deliverySha] : snap.units.map((unit) => unit.finalSha);
+            const validShas = requiredShas.filter((sha) => typeof sha === 'string' && evidence_1.COMMIT_SHA_RE.test(sha));
+            if (requiredShas.length === 0 || validShas.length !== requiredShas.length)
+                continue;
+            let allAncestors = true;
+            try {
+                for (const sha of new Set(validShas)) {
+                    const r = await deps.git.run(['merge-base', '--is-ancestor', sha, integration], deps.project.path);
+                    if (r.code !== 0) {
+                        allAncestors = false;
+                        break;
+                    }
+                }
+            }
+            catch {
+                allAncestors = false;
+            }
+            if (!allAncestors)
+                continue;
+            const token = (0, ids_1.newId)();
+            if (!(0, rail_pr_store_1.claimPrDeliveryOperation)(deps.db, other.id, other.decision, 'poll-merge', token))
+                continue;
+            let released = false;
+            try {
+                const claimed = { ...other, operation_token: token };
+                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, claimed),
+                });
+                await (0, ownership_1.deleteOwnedBranchesIfUnchanged)(deps, claimed, snap, cleanupWarnings);
+                const conflict = (0, transitions_1.casTransitionWithTicketEffect)(deps, claimed, 'merged', {
+                    deliveryOutcome: 'delivered',
+                    statusCode: cleanupWarnings.length > 0 ? 'cleanup_incomplete' : 'merged',
+                    statusDetail: `merged as part of ${mergedRow.rail_key}`,
+                    cleanupWarnings,
+                }, {
+                    deliveryId: claimed.id,
+                    ticketIds: snap.ticketIds,
+                    targetStatus: 'done',
+                    jiraAction: 'merged',
+                    prUrl: claimed.pr_url,
+                });
+                if (conflict)
+                    continue;
+                (0, transitions_1.applyTerminalTicketEffect)(deps, claimed, 'merged', cleanupWarnings);
+                // Release BEFORE finalizing: a row still holding a lease defers its
+                // broadcast to the lease owner's finally, which here would never come.
+                (0, rail_pr_store_1.releasePrDeliveryOperation)(deps.db, other.id, token);
+                released = true;
+                (0, transitions_1.finalizeTransition)(deps, other.id);
+                swept.push(other.id);
+            }
+            catch (err) {
+                console.error(`[milestone-chain] ancestor sweep failed for ${other.id}:`, err);
+            }
+            finally {
+                if (!released)
+                    (0, rail_pr_store_1.releasePrDeliveryOperation)(deps.db, other.id, token);
+            }
+        }
+    }
+    return swept;
+}
+/** A discarded delivery that a chain's later chunks build on pauses those
+ *  chains (`head_discarded`, head rewound to the previous chunk's branch). */
+function pauseChainsOnDiscard(deps, row) {
+    if (deps.repositoryChildOf)
+        return;
+    try {
+        const branchOf = (id) => {
+            const other = (0, rail_pr_store_1.getPrDelivery)(deps.db, id);
+            if (!other)
+                return null;
+            const s = (0, rail_pr_store_1.toPrDeliverySnapshot)(other);
+            return s.branch ?? s.units.find((u) => u.succeeded && u.branch)?.branch ?? null;
+        };
+        const paused = (0, milestone_chain_store_1.pauseChainsForDiscardedHead)(deps.db, row.id, branchOf);
+        for (const chain of paused) {
+            deps.broadcast({ type: 'milestone.chain_changed', projectId: deps.project.id, chain: (0, milestone_chain_store_1.toChainSnapshot)(chain), timestamp: new Date().toISOString() });
+        }
+    }
+    catch (err) {
+        console.error('[milestone-chain] discard hook failed:', err);
+    }
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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