specrails-desktop 2.36.0 → 2.42.2

package/server/dist/rail-isolated-launch.js

@@ -74,6 +74,8 @@ const db_1 = require("./db");
 const delivery_evidence_1 = require("./delivery-evidence");
 const integration_branch_1 = require("./integration-branch");
 const repo_lock_1 = require("./repo-lock");
+const project_repositories_1 = require("./project-repositories");
+const multi_repo_execution_store_1 = require("./multi-repo-execution-store");
 const rail_isolation_1 = require("./rail-isolation");
 const rail_pr_store_1 = require("./rail-pr-store");
 const agent_chat_registry_1 = require("./agent-chat-registry");
@@ -92,6 +94,7 @@ const active_pr_continuation_1 = require("./active-pr-continuation");
 const pr_lifecycle_1 = require("./pr-lifecycle");
 const rail_worktree_release_1 = require("./rail-worktree-release");
 const rail_pr_recovery_git_1 = require("./rail-pr-recovery-git");
+const loop_graph_1 = require("./loop-graph");
 /** A PR follow-up may only run on the verified PR branch in a dedicated
  * worktree. Routers must surface this error instead of degrading to shared cwd. */
 class PrContinuationIsolationError extends Error {
@@ -371,12 +374,31 @@ function branchRecords(results) {
 /**
  * Launch the rail's tickets in isolated worktrees + schedule the merge-back.
  * Returns the loop run ids. Throws if worktree allocation fails, but only after
- * tearing down owned partial allocation. A fresh launch may degrade to shared
- * cwd in the router; a PR continuation raises PrContinuationIsolationError and
- * must fail closed because shared cwd cannot prove which branch receives work.
+ * tearing down owned partial allocation. The router refuses shared-cwd
+ * fallback for these errors; execution stays bound to a verified worktree.
  */
 async function launchIsolatedRail(input, io = {}) {
     const { ctx, railIndex, ticketIds, loopId, loopName, loopGraph, provider, model, effort } = input;
+    let expectedRepositoryBaseSha = input.repositoryExecution?.expectedBaseSha;
+    let singleRepositoryId = input.repositoryExecution?.repositoryId;
+    if (!input.repositoryExecution) {
+        const members = (0, project_repositories_1.getProjectRepositories)(ctx.project);
+        const primary = members.find((repo) => repo.isPrimary) ?? members[0];
+        const selected = input.repositoryIds ?? (ticketIds.length === 0 && primary ? [primary.id] : [...new Set(ticketIds.flatMap((id) => {
+                const ids = ctx.getTicketSpec(id)?.repositoryIds;
+                return ids?.length ? ids : primary ? [primary.id] : [];
+            }))]);
+        (0, loop_graph_1.assertLoopShellRepositoryScope)(loopGraph, selected);
+        if (primary && selected.length === 1 && selected[0] === primary.id) {
+            input = { ...input, baseBranch: input.repositoryBaseBranches?.[primary.id] ?? input.baseBranch };
+            singleRepositoryId = primary.id;
+            expectedRepositoryBaseSha = input.repositoryBaseShas?.[primary.id];
+        }
+        if (selected.length !== 1 || selected[0] !== primary?.id) {
+            const { launchMultiRepositoryRail } = await Promise.resolve().then(() => __importStar(require('./multi-repo-execution')));
+            return launchMultiRepositoryRail({ ...input, repositoryIds: selected }, io);
+        }
+    }
     const git = io.git ?? worktree_manager_1.defaultGitRunner;
     const exec = io.exec ?? pr_publisher_1.defaultExec;
     const create = io.create ?? worktree_manager_1.createWorktree;
@@ -385,7 +407,7 @@ async function launchIsolatedRail(input, io = {}) {
     const resolveExecution = io.resolveExecution ?? workspace_resolution_1.resolveProjectExecution;
     const baseRepo = ctx.project.path;
     const slug = ctx.project.slug;
-    const worktreesRoot = path.join((0, artifact_registry_1.resolveHome)(), '.specrails', 'projects', slug, 'worktrees');
+    const worktreesRoot = path.join((0, artifact_registry_1.resolveHome)(), '.specrails', 'projects', slug, 'worktrees', ...(input.repositoryExecution ? [input.repositoryExecution.repositoryId] : []));
     // A revision run is seeded with a full briefing (the instruction PLUS the
     // frozen spec, the branch that carries the work and what the previous run
     // actually reported) rather than the bare sentence — the run starts a FRESH
@@ -400,7 +422,7 @@ async function launchIsolatedRail(input, io = {}) {
         : (0, loop_constants_1.loadConstantMap)(ctx.desktopDb);
     // 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 = (0, rail_isolation_1.isRailPrDeliveryEnabled)();
+    const prMode = Boolean(input.repositoryExecution) || (0, rail_isolation_1.isRailPrDeliveryEnabled)();
     // Ask-first PR delivery (safe-pr-review-flow): persist the authoritative
     // decision row UP FRONT (decision='building') — so the origin link survives
     // every await and late-joining clients hydrate mid-build via GET /rails —
@@ -472,7 +494,7 @@ async function launchIsolatedRail(input, io = {}) {
     // run — the batch pipeline handles the tickets internally); `per-ticket` → one
     // unit per ticket. The branch/ledger key is the unit's primary (first) ticket.
     const scope = input.scope ?? 'per-ticket';
-    let units = scope === 'all'
+    let units = input.repositoryExecution && ticketIds.length === 0 ? [{ ticketId: 0, ticketIds: [] }] : scope === 'all'
         ? [{ ticketId: ticketIds[0], ticketIds: [...ticketIds] }]
         : ticketIds.map((id) => ({ ticketId: id, ticketIds: [id] }));
     // Effective artifact root for the per-worktree overlay: a RELOCATED project's
@@ -544,9 +566,12 @@ async function launchIsolatedRail(input, io = {}) {
             // Resolve the project's designated integration branch ONCE, and branch every
             // ticket's worktree off it (not the ambient HEAD). Empty setting → auto-resolve
             // (repo default → HEAD fallback). See server/integration-branch.ts.
+            const executionRepository = (0, project_repositories_1.getProjectRepositories)(ctx.project).find((repo) => input.repositoryExecution
+                ? repo.id === input.repositoryExecution.repositoryId : repo.isPrimary);
             integration = await (0, integration_branch_1.resolveIntegrationBranch)(git, {
                 repoDir: baseRepo,
-                projectSetting: (0, db_1.getProjectSettings)(ctx.db).integrationBranch,
+                explicit: input.baseBranch ?? undefined,
+                projectSetting: executionRepository?.integrationBranch ?? (input.repositoryExecution && !input.repositoryExecution.primary ? undefined : (0, db_1.getProjectSettings)(ctx.db).integrationBranch),
             });
             // Prefer the freshly-fetched remote-tracking ref (origin/<branch>) over the
             // bare local name for repo-default/project-setting sources — see
@@ -644,6 +669,9 @@ async function launchIsolatedRail(input, io = {}) {
             }
             if (prMode) {
                 const generation = (0, rail_pr_store_1.createPrDeliveryGeneration)(ctx.db, {
+                    parentDeliveryId: input.repositoryExecution?.parentDeliveryId,
+                    repositoryId: input.repositoryExecution?.repositoryId,
+                    repositoryPath: input.repositoryExecution ? baseRepo : undefined,
                     railIndex,
                     loopId,
                     railKey: `${railIndex}-${loopId}`,
@@ -709,6 +737,9 @@ async function launchIsolatedRail(input, io = {}) {
             const takenBranches = await (0, worktree_manager_1.listLocalBranches)(git, baseRepo);
             const preexistingBranches = new Set(takenBranches);
             const unitBranchName = (ticketId) => {
+                const revisionBranch = input.repositoryExecution?.revisionBranches?.get(ticketId);
+                if (revisionBranch)
+                    return { branch: revisionBranch.branch, ownership: 'preexisting' };
                 const continuation = launchContinuation && continuationTargets.get(ticketId);
                 if (continuation) {
                     takenBranches.add(continuation.branch);
@@ -716,7 +747,10 @@ async function launchIsolatedRail(input, io = {}) {
                 }
                 const preferred = (0, pr_naming_1.ticketBranchName)(unitNamingInput(ctx, ticketId));
                 const branch = (0, pr_naming_1.resolveCollisionFreeName)(preferred, {
-                    taken: (name) => takenBranches.has(name) && !(0, rail_worktrees_store_1.railWorktreeBranchExistsForTicket)(ctx.db, ticketId, name),
+                    // A grouped 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)),
                     reserved: [integration.branch],
                 }) ?? (0, worktree_manager_1.worktreeBranch)(slug, ticketId);
                 takenBranches.add(branch);
@@ -731,12 +765,19 @@ async function launchIsolatedRail(input, io = {}) {
                     let worktreeOwnership = 'created';
                     let initialSha = null;
                     try {
+                        const revisionBranch = input.repositoryExecution?.revisionBranches?.get(unit.ticketId);
+                        if (revisionBranch) {
+                            const observed = await git.run(['rev-parse', '--verify', `refs/heads/${revisionBranch.branch}`], baseRepo);
+                            if (observed.code !== 0 || observed.stdout.trim() !== revisionBranch.sha) {
+                                throw new Error(`Revision branch ${revisionBranch.branch} no longer matches its recorded delivery commit`);
+                            }
+                        }
                         handle = await create(git, {
                             repoDir: baseRepo,
                             worktreesRoot,
                             slug,
                             ticketId: unit.ticketId,
-                            baseRef: continuationTarget?.baseRef ?? worktreeBaseRef.baseRef,
+                            baseRef: revisionBranch?.sha ?? continuationTarget?.baseRef ?? worktreeBaseRef.baseRef,
                             branch: branchPlan.branch,
                             refreshFromBaseRef: Boolean(continuationTarget?.baseRef),
                         });
@@ -749,6 +790,11 @@ async function launchIsolatedRail(input, io = {}) {
                         }
                         else {
                             initialSha = await readHeadSha(git, handle.worktreePath);
+                            if (expectedRepositoryBaseSha && initialSha !== expectedRepositoryBaseSha)
+                                throw new Error('The repository base changed before its worktree could be frozen');
+                            if (revisionBranch && (handle.branch !== revisionBranch.branch || initialSha !== revisionBranch.sha)) {
+                                throw new Error(`Revision checkout does not expose the exact recorded branch ${revisionBranch.branch}`);
+                            }
                         }
                         // Per-run overlay: merge-link the framework surface the checkout didn't
                         // bring into the worktree (idempotent; resume-safe via its manifest).
@@ -806,10 +852,12 @@ async function launchIsolatedRail(input, io = {}) {
                                 console.warn(`[rail-isolated] provenance snapshot failed: ${err.message}`);
                             }
                         }
-                        const runId = (0, ids_1.newId)();
+                        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,
+                            repositoryId: input.repositoryExecution?.repositoryId,
+                            repositoryPath: input.repositoryExecution ? baseRepo : undefined,
                             branch: handle.branch, worktreePath: handle.worktreePath,
                         });
                         allocated.push({
@@ -910,6 +958,7 @@ async function launchIsolatedRail(input, io = {}) {
                 runId: a.runId,
                 ticketId: a.ticketId,
                 repoDir: a.handle.worktreePath,
+                repositoryId: input.repositoryExecution?.repositoryId,
                 snapshot: a.provenanceSnapshot,
                 broadcast: (msg) => ctx.broadcast(msg),
             });
@@ -934,19 +983,33 @@ async function launchIsolatedRail(input, io = {}) {
     const settleAllocatedRun = async (a, enginePromise) => {
         let actualOutcome = 'failed';
         let engineFailure;
+        let stallReason;
         try {
             const result = await enginePromise;
             actualOutcome = result.outcome;
+            stallReason = result.stallReason;
         }
         catch (err) {
             engineFailure = errorDetail(err);
             console.error(`[rail-isolated] loop run ${a.runId} rejected: ${engineFailure}`);
         }
+        if (input.repositoryExecution?.isAborted?.()) {
+            // The coordinator never started. Do not commit incidental edits or
+            // release a mount borrowed from a previous delivery while rolling back.
+            const finalSha = await readHeadSha(git, a.handle.worktreePath);
+            if (a.worktreeOwnership !== 'created')
+                markWorktree(a, 'needs-review');
+            return {
+                run: a, implementationOutcome: 'failed', deliveryOutcome: 'not_started',
+                initialSha: a.initialSha, finalSha, changed: Boolean(finalSha && a.initialSha !== finalSha),
+                safeToRelease: a.worktreeOwnership === 'created' && finalSha !== null && finalSha === a.initialSha,
+            };
+        }
         const implementationOutcome = actualOutcome === 'success' ? 'succeeded' : 'failed';
         recordRunProvenance(a);
         let callbackFailure;
         try {
-            ctx.onLoopRunFinished(a.runId, actualOutcome, runFinishedOpts);
+            ctx.onLoopRunFinished(a.runId, actualOutcome, { ...runFinishedOpts, ...(stallReason ? { stallReason } : {}) });
         }
         catch (err) {
             callbackFailure = errorDetail(err);
@@ -1112,12 +1175,23 @@ async function launchIsolatedRail(input, io = {}) {
         const enginePromise = ctx.loopRunManager.run({
             runId: a.runId, loopId, loopName, graph: loopGraph, projectId: ctx.project.id,
             cwd: a.handle.worktreePath, repoDir: a.handle.worktreePath,
+            repositoryId: singleRepositoryId,
             isolation: { branch: a.handle.branch, worktreePath: a.handle.worktreePath },
-            railIndex, ticketId: a.ticketId,
-            spec: spec ? { ...spec, ticketIds: a.ticketIds } : { ticketIds: a.ticketIds },
+            railIndex, ticketId: a.ticketIds.length ? a.ticketId : null,
+            spec: {
+                ...spec,
+                ticketIds: a.ticketIds,
+                ...(a.ticketIds.length > 1 ? {
+                    tickets: a.ticketIds.map((id) => {
+                        const ticket = ctx.getTicketSpec(id);
+                        return { id, title: ticket?.title, description: ticket?.description, repositoryIds: ticket?.repositoryIds };
+                    }),
+                } : {}),
+            },
             ticketCompletionStatus: runFinishedOpts.ticketCompletionStatus,
             deferTerminalOutcome: true,
             constants, provider, model, effort,
+            profileName: input.profileName,
         });
         runPromises.push(settleAllocatedRun(a, enginePromise));
         try {
@@ -1454,6 +1528,7 @@ async function launchIsolatedRail(input, io = {}) {
                     ticketId: result.run.ticketId,
                     runId: result.run.runId,
                     worktreePath: result.run.handle.worktreePath,
+                    loopId,
                 })));
             }
             catch (e) {
@@ -1592,7 +1667,7 @@ async function launchIsolatedRail(input, io = {}) {
             broadcastPrState();
             syncOriginCard('update');
         }
-    });
+    }).finally(() => { input.repositoryExecution?.onSettled(prDeliveryId); });
     return allocated.map((a) => a.runId);
 }
 function recoveryOverlayExcludes(repoDir, worktreePath) {
@@ -1712,8 +1787,25 @@ async function reconcileRailWorktrees(db, repoDir, io = {}) {
     const git = io.git ?? worktree_manager_1.defaultGitRunner;
     const exec = io.exec ?? pr_publisher_1.defaultExec;
     const remove = io.remove ?? worktree_manager_1.removeWorktree;
+    if (!io.repositoryOnly) {
+        const paths = db.prepare('SELECT DISTINCT repository_path FROM rail_worktrees WHERE repository_path IS NOT NULL UNION SELECT DISTINCT repository_path FROM rail_pr_deliveries WHERE repository_path IS NOT NULL').all();
+        if (paths.length) {
+            let count = 0;
+            for (const target of [...new Set([repoDir, ...paths.map((row) => row.repository_path)])]) {
+                count += await reconcileRailWorktrees(db, target, { ...io, repositoryOnly: true, primaryRepoDir: repoDir });
+            }
+            const { refreshRepositoryDeliveryGroup } = await Promise.resolve().then(() => __importStar(require('./multi-repo-execution')));
+            const groups = db.prepare('SELECT id FROM rail_pr_deliveries WHERE parent_delivery_id IS NULL AND execution_manifest IS NOT NULL').all();
+            for (const group of groups) {
+                refreshRepositoryDeliveryGroup(db, group.id, { startup: true });
+                io.onDeliveryRecovered?.(group.id);
+            }
+            return count;
+        }
+    }
+    const belongsHere = (row) => (row.repository_path ?? io.primaryRepoDir ?? repoDir) === repoDir;
     return (0, repo_lock_1.withRepoLock)(repoDir, async () => {
-        const stuck = (0, rail_worktrees_store_1.listNonTerminalRailWorktrees)(db);
+        const stuck = (0, rail_worktrees_store_1.listNonTerminalRailWorktrees)(db).filter(belongsHere);
         const autoReleaseWorktreeIds = new Set();
         const settledDeliveries = db.prepare(`
       SELECT decision, delivery_outcome, worktree_ids FROM rail_pr_deliveries
@@ -1787,7 +1879,38 @@ async function reconcileRailWorktrees(db, repoDir, io = {}) {
             // mismatch are all recoverable uncertainty. Never force-remove them.
             (0, rail_worktrees_store_1.updateRailWorktreeState)(db, row.id, 'needs-review');
         }
-        const recovered = (0, rail_pr_store_1.reconcileFailedBuildingPrDeliveries)(db, { startup: true });
+        const recovered = (0, rail_pr_store_1.reconcileFailedBuildingPrDeliveries)(db, { startup: true, repositoryPath: repoDir, legacyRepositoryPath: io.primaryRepoDir ?? repoDir });
+        // Multi-repository recovery must not conflate the same run/branch names
+        // across object stores. Promote only a clean unchanged base or an exact
+        // app-marked settlement commit; retain uncertain work for explicit revision.
+        for (const delivery of recovered) {
+            const manifest = (0, multi_repo_execution_store_1.readExecutionManifest)(delivery.execution_manifest);
+            if (!delivery.parent_delivery_id || !manifest || delivery.pr_url || delivery.implementation_outcome !== 'succeeded')
+                continue;
+            const units = (0, rail_pr_store_1.toPrDeliverySnapshot)(delivery).branches;
+            const recoveredUnits = await Promise.all(units.map(async (unit) => {
+                const ledger = stuck.find((row) => row.run_id === unit.runId && row.branch === unit.branch);
+                const snapshot = manifest.repositories.find((repo) => repo.worktreeId === ledger?.id);
+                const sha = unit.runId ? verifiedShaByRun.get(unit.runId) : undefined;
+                const proven = Boolean(snapshot && sha && (sha === snapshot.baseSha || await (0, rail_pr_recovery_git_1.commitCarriesRunMarker)(git, repoDir, sha, unit.runId)));
+                const noChanges = proven && sha === snapshot.baseSha;
+                return {
+                    ...unit, repositoryId: delivery.repository_id ?? undefined,
+                    succeeded: proven && !noChanges, initialSha: snapshot?.baseSha ?? null, finalSha: proven ? sha : null,
+                    changed: proven ? !noChanges : undefined, worktreePath: ledger?.worktree_path,
+                    branchOwnership: 'preexisting', deliveryOutcome: proven ? noChanges ? 'no_changes' : 'ready' : 'blocked',
+                    failureCode: proven ? null : 'settlement_interrupted',
+                };
+            }));
+            const ready = recoveredUnits.filter((unit) => unit.deliveryOutcome === 'ready').length;
+            const unchanged = recoveredUnits.length > 0 && recoveredUnits.every((unit) => unit.deliveryOutcome === 'no_changes');
+            const blocked = recoveredUnits.some((unit) => unit.deliveryOutcome === 'blocked');
+            const next = blocked ? 'pr_failed' : unchanged ? 'no_changes' : ready ? 'on_review' : 'pr_failed';
+            (0, rail_pr_store_1.transitionDecision)(db, delivery.id, delivery.decision, next, {
+                branches: recoveredUnits, deliveryOutcome: blocked ? 'blocked' : unchanged ? 'no_changes' : 'ready',
+                statusCode: blocked ? 'settlement_interrupted' : unchanged ? 'no_changes' : 'ready_for_review',
+            });
+        }
         // Migration 49 repairs legacy false implementation failures before Git is
         // available. Revisit those already-pr_failed rows here: if their own
         // durable run/worktree ledger proves one exact clean object, the card can
@@ -1848,6 +1971,8 @@ async function reconcileRailWorktrees(db, repoDir, io = {}) {
             return recoveryProtectionScan;
         };
         for (const delivery of recoveryCandidates) {
+            if (!belongsHere(delivery))
+                continue;
             if (!['succeeded', 'partially_succeeded'].includes(delivery.implementation_outcome))
                 continue;
             // Exact-SHA promotion here is specifically an existing-PR retry. A fresh