specrails-desktop 2.58.1 → 2.59.1

package/server/dist/modules/delivery/runtime/rail-isolated-launch.js

@@ -163,21 +163,21 @@ function buildRevisionSeedForLaunch(db, revision, ticketIds, includeSpecBody = t
             depth += 1;
             cursor = (0, rail_pr_store_1.getPrDelivery)(db, cursor.revision_of) ?? undefined;
         }
-        return (0, revision_seed_1.buildRevisionSeed)({
-            note: revision.note,
-            includeSpecBody,
-            specSnapshot: previous ? (0, rail_pr_store_1.readSpecSnapshot)(previous.spec_snapshot) : null,
-            ticketIds: [...ticketIds],
-            branches,
-            baseBranch: previous?.base_branch ?? 'the integration branch',
-            branchDiffSummary: null,
-            evidence: previous ? (0, delivery_evidence_1.readSettleEvidence)(previous.settle_evidence) : null,
-            revisionNumber: depth,
-        });
+        return { number: depth, briefing: (0, revision_seed_1.buildRevisionSeed)({
+                note: revision.note,
+                includeSpecBody,
+                specSnapshot: previous ? (0, rail_pr_store_1.readSpecSnapshot)(previous.spec_snapshot) : null,
+                ticketIds: [...ticketIds],
+                branches,
+                baseBranch: previous?.base_branch ?? 'the integration branch',
+                branchDiffSummary: null,
+                evidence: previous ? (0, delivery_evidence_1.readSettleEvidence)(previous.settle_evidence) : null,
+                revisionNumber: depth,
+            }) };
     }
     catch {
         // Absolute floor: the user's instruction still reaches the run.
-        return revision.note;
+        return { briefing: revision.note, number: 1 };
     }
 }
 /**
@@ -473,7 +473,7 @@ function createIsolatedRunSettlement(ports) {
         }
         let commit;
         try {
-            commit = await (0, worktree_manager_1.commitWorktreeAndVerify)(git, a.handle.worktreePath, commitMessage(a, implementationOutcome === 'failed'), a.overlayExcludes);
+            commit = await (0, worktree_manager_1.commitWorktreeAndVerify)(git, a.handle.worktreePath, commitMessage(a, implementationOutcome === 'failed'), a.overlayExcludes, a.hygieneBaseSha ?? a.initialSha ?? a.baseRef);
         }
         catch (err) {
             commit = { staged: false, committed: false, clean: false, dirty: [], error: errorDetail(err) };
@@ -638,10 +638,13 @@ async function launchIsolatedRail(input, io = {}) {
     // provider session by contract, so durable context is the only thing it has.
     // Per-RUN data, so it is layered over the project's constant map for this
     // launch only and never persisted as a constant.
-    const constants = input.revision
+    const revisionSeed = input.revision ? buildRevisionSeedForLaunch(ctx.db, input.revision, ticketIds, !['factory:sdd-quick-openspec', 'factory:openspec', 'factory:revision'].includes(loopId)) : undefined;
+    const constants = input.revision && revisionSeed
         ? {
             ...(0, loop_constants_1.loadConstantMap)(ctx.desktopDb),
-            REVISION_REQUEST: buildRevisionSeedForLaunch(ctx.db, input.revision, ticketIds, !['factory:sdd-quick-openspec', 'factory:openspec', 'factory:revision'].includes(loopId)),
+            REVISION_REQUEST: revisionSeed.briefing,
+            REVISION_NUMBER: String(revisionSeed.number),
+            REVISION_OF_DELIVERY_ID: input.revision.ofDeliveryId,
         }
         : (0, loop_constants_1.loadConstantMap)(ctx.desktopDb);
     // Spec addenda (spec-addenda): the iteration notes the specs carry are
@@ -650,6 +653,7 @@ async function launchIsolatedRail(input, io = {}) {
     // briefing every AI step of the run receives.
     const addendaStorePath = (0, spec_addenda_1.ticketStorePathForProject)(ctx.project);
     const addendaPlan = (0, spec_addenda_1.planSpecAddendaAt)(addendaStorePath, ticketIds);
+    const claimedAddendaByRun = new Map();
     // Capture the PR-delivery mode ONCE at launch entry so a mid-flight env flip
     // can never split one launch across the two delivery paths.
     const prMode = Boolean(input.repositoryExecution) || (0, rail_isolation_1.isRailPrDeliveryEnabled)();
@@ -921,6 +925,7 @@ async function launchIsolatedRail(input, io = {}) {
             }
             if (prMode) {
                 const generation = (0, rail_pr_store_1.createPrDeliveryGeneration)(ctx.db, {
+                    launchConfig: input.launchConfig,
                     parentDeliveryId: input.repositoryExecution?.parentDeliveryId,
                     repositoryId: input.repositoryExecution?.repositoryId,
                     repositoryPath: input.repositoryExecution ? baseRepo : undefined,
@@ -947,7 +952,9 @@ async function launchIsolatedRail(input, io = {}) {
                     // predecessor through the shipped rollback path.
                     : input.revision
                         ? { id: input.revision.ofDeliveryId, decision: input.revision.decision }
-                        : null);
+                        : input.retryOfDelivery
+                            ? { id: input.retryOfDelivery.deliveryId, decision: input.retryOfDelivery.decision }
+                            : null);
                 prDeliveryId = generation.delivery.id;
                 supersededDelivery = generation.superseded;
                 input.onPrDeliveryCreated?.(prDeliveryId);
@@ -983,15 +990,28 @@ async function launchIsolatedRail(input, io = {}) {
             }
             // Conventional branch naming (pr-naming): `<type>/<ref>-<kebab-title>`, the
             // Jira key prevailing over the local id when linked. Collisions with foreign
-            // branches suffix `-2`… (bounded); a branch a PRIOR rail run allocated for
-            // the SAME ticket is ours to resume, so it is NOT treated as a collision.
+            // branches suffix `-2`… (bounded). Ordinary launches start a new sibling;
+            // only exact recorded revision/PR branches can be reused.
             // The integration branch is never used; exhaustion falls back to the legacy
             // `sr/<slug>/ticket-<id>` name. Snapshot under the lock so concurrent
             // launches see each other's just-created branches.
             const takenBranches = await (0, worktree_manager_1.listLocalBranches)(git, baseRepo);
             const preexistingBranches = new Set(takenBranches);
+            const hygieneBase = await git.run(['rev-parse', '--verify', `${worktreeBaseRef.baseRef}^{commit}`], baseRepo);
+            if (hygieneBase.code !== 0)
+                throw new Error('Could not freeze the OpenSpec delivery baseline');
+            const hygieneBaseSha = /^[a-f0-9]{40,64}$/i.test(hygieneBase.stdout.trim()) ? hygieneBase.stdout.trim() : null;
+            const revisionBranches = input.repositoryExecution?.revisionBranches ?? new Map();
+            if (input.revision && !input.repositoryExecution && !launchContinuation) {
+                const previous = (0, rail_pr_store_1.getPrDelivery)(ctx.db, input.revision.ofDeliveryId);
+                for (const unit of previous ? (0, rail_pr_store_1.toPrDeliverySnapshot)(previous).branches : []) {
+                    if (unit.succeeded && unit.finalSha && unit.implementationOutcome !== 'failed' && unit.deliveryOutcome !== 'blocked') {
+                        revisionBranches.set(unit.ticketId, { branch: unit.branch, sha: unit.finalSha });
+                    }
+                }
+            }
             const unitBranchName = (ticketId) => {
-                const revisionBranch = input.repositoryExecution?.revisionBranches?.get(ticketId);
+                const revisionBranch = revisionBranches.get(ticketId);
                 if (revisionBranch)
                     return { branch: revisionBranch.branch, ownership: 'preexisting' };
                 const continuation = launchContinuation && continuationTargets.get(ticketId);
@@ -1001,10 +1021,10 @@ async function launchIsolatedRail(input, io = {}) {
                 }
                 const preferred = (0, pr_naming_1.ticketBranchName)(unitNamingInput(ctx, ticketId));
                 const branch = (0, pr_naming_1.resolveCollisionFreeName)(preferred, {
-                    // A grouped run can reuse a branch only through the exact revision/PR
+                    // A run can reuse a branch only through the exact revision/PR
                     // evidence above. An accepted predecessor may now lag the integration
                     // branch, so ordinary grouped allocations must start a fresh branch.
-                    taken: (name) => takenBranches.has(name) && (Boolean(input.repositoryExecution) || !(0, rail_worktrees_store_1.railWorktreeBranchExistsForTicket)(ctx.db, ticketId, name)),
+                    taken: (name) => takenBranches.has(name),
                     reserved: [integration.branch],
                 }) ?? (0, worktree_manager_1.worktreeBranch)(slug, ticketId);
                 takenBranches.add(branch);
@@ -1012,6 +1032,7 @@ async function launchIsolatedRail(input, io = {}) {
             };
             try {
                 for (const unit of units) {
+                    const runId = input.repositoryExecution?.runIds.get(unit.ticketId) ?? (0, ids_1.newId)();
                     const continuationTarget = launchContinuation ? continuationTargets.get(unit.ticketId) ?? null : null;
                     const branchPlan = unitBranchName(unit.ticketId);
                     let handle = null;
@@ -1019,7 +1040,9 @@ async function launchIsolatedRail(input, io = {}) {
                     let worktreeOwnership = 'created';
                     let initialSha = null;
                     try {
-                        const revisionBranch = input.repositoryExecution?.revisionBranches?.get(unit.ticketId);
+                        const revisionBranch = revisionBranches.get(unit.ticketId);
+                        if (input.revision && !input.repositoryExecution && !launchContinuation && !revisionBranch)
+                            throw new Error('Revision requires a recorded delivered branch for every ticket');
                         if (revisionBranch) {
                             const observed = await git.run(['rev-parse', '--verify', `refs/heads/${revisionBranch.branch}`], baseRepo);
                             if (observed.code !== 0 || observed.stdout.trim() !== revisionBranch.sha) {
@@ -1028,12 +1051,14 @@ async function launchIsolatedRail(input, io = {}) {
                         }
                         handle = await create(git, {
                             repoDir: baseRepo,
-                            worktreesRoot,
+                            worktreesRoot: path.join(worktreesRoot, runId),
                             slug,
                             ticketId: unit.ticketId,
                             baseRef: revisionBranch?.sha ?? continuationTarget?.baseRef ?? worktreeBaseRef.baseRef,
                             branch: branchPlan.branch,
                             refreshFromBaseRef: Boolean(continuationTarget?.baseRef),
+                            fresh: !revisionBranch && !continuationTarget,
+                            reuseBranchWorktree: Boolean(revisionBranch || continuationTarget),
                         });
                         worktreeOwnership = handle.worktreeCreated === false ? 'preexisting' : 'created';
                         if (!continuationTarget && (handle.branch !== branchPlan.branch || handle.branchCreated === false)) {
@@ -1106,7 +1131,6 @@ async function launchIsolatedRail(input, io = {}) {
                                 console.warn(`[rail-isolated] provenance snapshot failed: ${err.message}`);
                             }
                         }
-                        const runId = input.repositoryExecution?.runIds.get(unit.ticketId) ?? (0, ids_1.newId)();
                         const ledgerId = (0, ids_1.newId)();
                         (0, rail_worktrees_store_1.createRailWorktree)(ctx.db, {
                             id: ledgerId, railIndex, ticketId: unit.ticketId, runId,
@@ -1126,6 +1150,7 @@ async function launchIsolatedRail(input, io = {}) {
                             provenanceSnapshot,
                             continuationTarget,
                             baseRef: continuationTarget?.baseRef ?? worktreeBaseRef.baseRef,
+                            hygieneBaseSha,
                             initialSha,
                             branchOwnership,
                             worktreeOwnership,
@@ -1158,9 +1183,23 @@ async function launchIsolatedRail(input, io = {}) {
                                 partialCommitMessage: worktreeCommitMessage(ctx, run.ticketId, run.runId, true), run,
                             });
                     })();
+                // Freeze every addendum claim before any sibling can start Core. A missing
+                // store or failed claim must never silently turn a delta into an unbriefed run.
+                for (const run of allocated) {
+                    const plan = addendaPlan.filter(entry => run.ticketIds.includes(entry.ticketId)).map(entry => input.retryOfDelivery ? { ...entry, status: null } : launchContinuation || input.revision || input.repositoryContinuation ? { ...entry, status: 'on_review' } : entry);
+                    const claimed = (0, spec_addenda_1.claimSpecAddendaForRun)(addendaStorePath, run.ticketIds, run.runId, { plan });
+                    claimedAddendaByRun.set(run.runId, claimed);
+                    const expected = (0, spec_addenda_1.snapshotSpecAddenda)(plan);
+                    if (expected.some(entry => !claimed.snapshot.some(actual => actual.ticketId === entry.ticketId && actual.id === entry.id && actual.hash === entry.hash)) || (expected.length && !claimed.briefing)) {
+                        throw new Error('Could not claim the complete frozen spec addenda; no implementation was started. Restore ticket storage and retry.');
+                    }
+                    (0, spec_addenda_1.broadcastSpecAddendaChange)(msg => ctx.broadcast(msg), ctx.project.id, claimed);
+                }
             }
             catch (err) {
                 for (const a of allocated) {
+                    if (claimedAddendaByRun.has(a.runId))
+                        (0, spec_addenda_1.broadcastSpecAddendaChange)(msg => ctx.broadcast(msg), ctx.project.id, (0, spec_addenda_1.settleSpecAddendaAt)(addendaStorePath, a.ticketIds, a.runId, 'failed'));
                     if (a.worktreeOwnership === 'created') {
                         await remove(git, {
                             repoDir: baseRepo,
@@ -1265,16 +1304,13 @@ async function launchIsolatedRail(input, io = {}) {
             requiresTerminalIntent: true,
         });
         const spec = ctx.getTicketSpec(a.ticketId);
-        const claimedAddenda = (0, spec_addenda_1.claimSpecAddendaForRun)(addendaStorePath, a.ticketIds, a.runId, {
-            plan: addendaPlan.filter((e) => a.ticketIds.includes(e.ticketId)).map((entry) => launchContinuation || input.revision || input.repositoryContinuation
-                ? { ...entry, status: 'on_review' } : entry),
-        });
-        (0, spec_addenda_1.broadcastSpecAddendaChange)((msg) => ctx.broadcast(msg), ctx.project.id, claimedAddenda);
+        const claimedAddenda = claimedAddendaByRun.get(a.runId);
         const enginePromise = ctx.loopRunManager.run({
             runtimeProviderOverride: input.runtimeProviderOverride,
-            runId: a.runId, loopId, loopName, graph: loopGraph, projectId: ctx.project.id,
+            runId: a.runId, loopId, loopName, graph: loopGraph, projectId: ctx.project.id, launchConfig: input.launchConfig,
             cwd: a.handle.worktreePath, repoDir: a.handle.worktreePath,
             repositoryId: singleRepositoryId,
+            workspacePaths: singleRepositoryId ? input.workspaceSelection?.[singleRepositoryId] : undefined,
             isolation: { branch: a.handle.branch, worktreePath: a.handle.worktreePath },
             railIndex, ticketId: a.ticketIds.length ? a.ticketId : null,
             spec: {

package/server/dist/modules/delivery/runtime/rail-launch-parser.js

@@ -75,6 +75,12 @@ function coerceRailLaunchProposal(value) {
     const mode = modeRaw === 'batch' || modeRaw === 'batch-implement' ? 'implement' : modeRaw;
     if (!exports.RAIL_LAUNCH_MODES.includes(mode))
         return { ok: false, reason: 'invalid_mode' };
+    const repositoryIds = value.repositoryIds;
+    const workspaceSelection = value.workspaceSelection;
+    if (repositoryIds !== undefined && (!Array.isArray(repositoryIds) || !repositoryIds.length || repositoryIds.length > 50 || repositoryIds.some(id => typeof id !== 'string' || !id.trim()) || new Set(repositoryIds).size !== repositoryIds.length))
+        return { ok: false, reason: 'invalid_workspace_selection' };
+    if (workspaceSelection !== undefined && (!isRecord(workspaceSelection) || !Object.keys(workspaceSelection).length || Object.keys(workspaceSelection).length > 50 || Object.entries(workspaceSelection).some(([id, paths]) => !id.trim() || !Array.isArray(paths) || !paths.length || paths.length > 50 || paths.some(item => typeof item !== 'string' || !item.trim() || item.length > 4096) || new Set(paths).size !== paths.length)))
+        return { ok: false, reason: 'invalid_workspace_selection' };
     const newRailRaw = value.newRail;
     const newRail = newRailRaw === true
         ? { name: null }
@@ -89,6 +95,8 @@ function coerceRailLaunchProposal(value) {
             railIndex,
             newRail,
             ticketIds,
+            ...(repositoryIds !== undefined ? { repositoryIds: repositoryIds } : {}),
+            ...(workspaceSelection !== undefined ? { workspaceSelection: workspaceSelection } : {}),
             mode: mode,
             loopId: optString(value.loopId, 120),
             aiEngine: optString(value.aiEngine ?? value.provider ?? value.engine, 80),

package/server/dist/modules/delivery/runtime/rail-pr-store.js

@@ -101,11 +101,11 @@ function createPrDelivery(db, input) {
        loop_name, origin_surface, origin_conversation_id,
        implementation_outcome, delivery_outcome, status_code,
        is_continuation, supersedes_delivery_id, spec_snapshot,
-       revision_note, revision_of, parent_delivery_id, repository_id, repository_path, follow_up, spec_addenda
+       revision_note, revision_of, parent_delivery_id, repository_id, repository_path, follow_up, spec_addenda, launch_config_json
      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'running', 'pending',
-       'implementation_running', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, input.railIndex, input.loopId ?? null, input.railKey, JSON.stringify(input.ticketIds), input.baseBranch, input.loopName, input.originSurface, input.originConversationId ?? null, input.isContinuation ? 1 : 0, input.supersedesDeliveryId ?? null, input.specSnapshot && input.specSnapshot.length > 0
+       'implementation_running', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, input.railIndex, input.loopId ?? null, input.railKey, JSON.stringify(input.ticketIds), input.baseBranch, input.loopName, input.originSurface, input.originConversationId ?? null, input.isContinuation ? 1 : 0, input.supersedesDeliveryId ?? null, input.specSnapshot && input.specSnapshot.length > 0
         ? JSON.stringify(boundSpecSnapshot(input.specSnapshot))
-        : null, input.revisionNote ? boundRevisionNote(input.revisionNote) : null, input.revisionOf ?? null, input.parentDeliveryId ?? null, input.repositoryId ?? null, input.repositoryPath ?? null, input.followUp ? JSON.stringify(input.followUp) : null, input.specAddenda && input.specAddenda.length > 0 ? JSON.stringify(input.specAddenda) : null);
+        : null, input.revisionNote ? boundRevisionNote(input.revisionNote) : null, input.revisionOf ?? null, input.parentDeliveryId ?? null, input.repositoryId ?? null, input.repositoryPath ?? null, input.followUp ? JSON.stringify(input.followUp) : null, input.specAddenda && input.specAddenda.length > 0 ? JSON.stringify(input.specAddenda) : null, input.launchConfig ? JSON.stringify(input.launchConfig) : null);
     return getPrDelivery(db, id);
 }
 /**

package/server/dist/modules/delivery/runtime/rail-relaunch.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RailRelaunchError = void 0;
+exports.resolveRailRelaunch = resolveRailRelaunch;
+exports.assertRelaunchRail = assertRelaunchRail;
+exports.restoreRelaunchRail = restoreRelaunchRail;
+const loop_runs_store_1 = require("../../loops/runtime/loop-runs-store");
+const rail_pr_store_1 = require("./rail-pr-store");
+const rails_store_1 = require("./rails-store");
+class RailRelaunchError extends Error {
+    code;
+    action;
+    constructor(code, detail, action) {
+        super(detail);
+        this.code = code;
+        this.action = action;
+    }
+}
+exports.RailRelaunchError = RailRelaunchError;
+function jsonObject(raw) {
+    if (!raw)
+        return undefined;
+    const value = JSON.parse(raw);
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('Invalid saved launch configuration');
+    return value;
+}
+function historicalConfig(run) {
+    if (!run)
+        return {};
+    const request = jsonObject(run.run_request_json);
+    return {
+        mode: 'loop',
+        ...(run.loop_id ? { loopId: run.loop_id } : {}),
+        ...(run.provider ? { aiEngine: run.provider } : {}),
+        ...(run.model ? { model: run.model } : {}),
+        ...(run.reasoning_effort ? { reasoning_effort: run.reasoning_effort } : {}),
+        // These are launch options, not the old cwd, worktree, graph or run id.
+        ...(request?.profileName !== undefined ? { profileName: request.profileName } : {}),
+        ...(request?.runtimeProviderOverride ? { runtimeProviderOverride: request.runtimeProviderOverride } : {}),
+        ...(request?.repositoryId ? { repositoryIds: [request.repositoryId] } : {}),
+        ...(request?.repositoryId && request.workspacePaths ? { workspaceSelection: { [String(request.repositoryId)]: request.workspacePaths } } : {}),
+    };
+}
+function unavailable(code, detail) {
+    throw new RailRelaunchError(code, detail, 'Refresh the mission and configure a fresh launch on a free rail.');
+}
+/** Per-ticket launches share a rail but settle independently. A later sibling
+ * is not a replacement; only a run covering one of this source's specs is. */
+function latestOverlappingRun(c, railIndex, ticketIds) {
+    const ids = JSON.stringify(ticketIds);
+    return c.db.prepare(`SELECT id, status FROM loop_runs
+    WHERE rail_index = ? AND (ticket_id IN (SELECT value FROM json_each(?))
+      OR EXISTS (SELECT 1 FROM json_each(COALESCE(ticket_ids_json, '[]')) AS ticket
+        WHERE ticket.value IN (SELECT value FROM json_each(?))))
+    ORDER BY rowid DESC LIMIT 1`).get(railIndex, ids, ids);
+}
+/** Resolve the source in this project's database. A card never authorizes the
+ * current contents of its mutable rail slot, or arbitrary launch overrides. */
+function resolveRailRelaunch(c, railIndex, sourceId) {
+    if (typeof sourceId !== 'string' || !/^(?:run:)?[A-Za-z0-9-]{1,128}$/.test(sourceId)) {
+        unavailable('invalid_relaunch_source', 'Relaunch requires the original delivery or run id.');
+    }
+    let ticketIds, config, delivery;
+    if (sourceId.startsWith('run:')) {
+        const run = (0, loop_runs_store_1.getLoopRun)(c.db, sourceId.slice(4));
+        if (!run || run.project_id !== c.project.id || run.rail_index !== railIndex)
+            unavailable('relaunch_source_missing', 'The original run is unavailable in this project and rail.');
+        if (run.status !== 'completed')
+            unavailable('relaunch_source_active', 'The original run is still active or paused.');
+        ticketIds = JSON.parse(run.ticket_ids_json ?? '[]');
+        if (!ticketIds.length && run.ticket_id != null)
+            ticketIds = [run.ticket_id];
+        config = jsonObject(run.launch_config_json) ?? historicalConfig(run);
+        const newer = latestOverlappingRun(c, railIndex, ticketIds);
+        if (newer?.id !== run.id || (0, rail_pr_store_1.getActivePrDeliveryByRail)(c.db, railIndex))
+            unavailable('relaunch_source_stale', 'Another attempt has already replaced this run on the rail.');
+    }
+    else {
+        const row = (0, rail_pr_store_1.getPrDelivery)(c.db, sourceId);
+        if (!row || row.rail_index !== railIndex || row.parent_delivery_id)
+            unavailable('relaunch_source_missing', 'The original delivery is unavailable in this project and rail.');
+        delivery = (0, rail_pr_store_1.toPrDeliverySnapshot)(row);
+        if (!['implementation_failed', 'pr_failed'].includes(row.decision) && !(row.decision === 'discarded' && ['delivery_failed', 'cancelled'].includes(row.status_code ?? ''))) {
+            unavailable('relaunch_source_stale', 'The original delivery is no longer a failed attempt awaiting relaunch.');
+        }
+        if (row.operation_token)
+            unavailable('relaunch_source_busy', 'A delivery operation is still in progress.');
+        const active = (0, rail_pr_store_1.getActivePrDeliveryByRail)(c.db, railIndex);
+        const latest = c.db.prepare('SELECT id FROM rail_pr_deliveries WHERE rail_index = ? AND parent_delivery_id IS NULL ORDER BY rowid DESC LIMIT 1').get(railIndex);
+        if (active ? active.id !== sourceId : latest?.id !== sourceId)
+            unavailable('relaunch_source_stale', 'Another delivery has already replaced this attempt on the rail.');
+        ticketIds = delivery.ticketIds;
+        const run = delivery.runIds.map(id => (0, loop_runs_store_1.getLoopRun)(c.db, id)).find(Boolean);
+        const savedConfig = jsonObject(row.launch_config_json);
+        config = savedConfig ?? {
+            mode: 'loop',
+            ...historicalConfig(run),
+            ...(row.loop_id ? { loopId: row.loop_id } : {}),
+            ...(delivery.followUp ? { targetPrNumber: delivery.prNumber, followUp: delivery.followUp } : {}),
+        };
+        // Always retain the admitted base; ordinary launch defaults may have changed.
+        if (!config.baseBranch && row.base_branch)
+            config.baseBranch = row.base_branch;
+        if (delivery.executionManifest) {
+            config.repositoryIds = delivery.executionManifest.selectedRepositoryIds;
+            config.workspaceSelection = savedConfig?.workspaceSelection ?? Object.fromEntries(delivery.executionManifest.repositories
+                .filter(repo => repo.selectedWorkspacePaths).map(repo => [repo.repositoryId, repo.selectedWorkspacePaths]));
+        }
+    }
+    if (!Array.isArray(ticketIds) || !ticketIds.length || ticketIds.some(id => !Number.isSafeInteger(id) || id <= 0))
+        unavailable('relaunch_specs_unavailable', 'The original spec set is unavailable.');
+    if (typeof config.loopId !== 'string' || !config.loopId)
+        unavailable('relaunch_config_unavailable', 'The original workflow was not recorded; Relaunch cannot safely choose a replacement.');
+    // Revision identity belongs to the old generation. Retry uses the original
+    // complete spec set and the separate atomic retryOfDelivery contract.
+    const { revisionOfDeliveryId: _revisionId, revisionNote: _revisionNote, ...retryConfig } = config;
+    const source = { sourceId, ticketIds, config: retryConfig, delivery };
+    assertRelaunchRail(c, railIndex, source);
+    return source;
+}
+function assertRelaunchRail(c, railIndex, source) {
+    if (!(0, rails_store_1.railExists)(c.db, railIndex))
+        unavailable('relaunch_rail_missing', 'The original rail was removed.');
+    const rail = (0, rails_store_1.getRail)(c.db, railIndex);
+    if (rail.ticketIds.length && (rail.ticketIds.length !== source.ticketIds.length || rail.ticketIds.some(id => !source.ticketIds.includes(id)))) {
+        unavailable('relaunch_rail_changed', 'This rail now contains different specs. Relaunch has not changed or launched them.');
+    }
+    if (source.delivery) {
+        const current = (0, rail_pr_store_1.getPrDelivery)(c.db, source.sourceId);
+        const active = (0, rail_pr_store_1.getActivePrDeliveryByRail)(c.db, railIndex);
+        const latest = c.db.prepare('SELECT id FROM rail_pr_deliveries WHERE rail_index = ? AND parent_delivery_id IS NULL ORDER BY rowid DESC LIMIT 1').get(railIndex);
+        if (!current || current.decision !== source.delivery.decision || current.operation_token || (active ? active.id !== current.id : latest?.id !== current.id)) {
+            unavailable('relaunch_source_stale', 'The original delivery changed while Relaunch was being prepared.');
+        }
+    }
+    else {
+        const latest = latestOverlappingRun(c, railIndex, source.ticketIds);
+        if (latest?.id !== source.sourceId.slice(4) || latest.status !== 'completed' || (0, rail_pr_store_1.getActivePrDeliveryByRail)(c.db, railIndex)) {
+            unavailable('relaunch_source_stale', 'The original run changed while Relaunch was being prepared.');
+        }
+    }
+    return rail;
+}
+/** Called after preflight, immediately before admission. Empty assignment is
+ * terminal cleanup; a different assignment remains the user's current work. */
+function restoreRelaunchRail(c, railIndex, source) {
+    const rail = assertRelaunchRail(c, railIndex, source);
+    if (!rail.ticketIds.length) {
+        (0, rails_store_1.setRailTickets)(c.db, railIndex, source.ticketIds, String(source.config.mode ?? 'implement'), typeof source.config.profileName === 'string' ? source.config.profileName : null, typeof source.config.aiEngine === 'string' ? source.config.aiEngine : null);
+        return true;
+    }
+    return false;
+}