specrails-desktop 2.29.3 → 2.29.4

package/server/dist/rail-pr-decision.js

@@ -347,6 +347,7 @@ async function rerouteFromStalePr(deps, row, detail, exactWasPushed) {
         worktreeIds: 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: safetyArchiveRecorder(deps, row),
     });
     const partial = row.implementation_outcome === 'partially_succeeded';
@@ -386,6 +387,7 @@ async function settleObservedExistingPr(deps, row, observation, pushed) {
         worktreeIds: 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: safetyArchiveRecorder(deps, row),
     });
     const conflict = casTransition(deps, row, next, {
@@ -420,6 +422,7 @@ async function settleObservedClosedPr(deps, row, observation) {
         worktreeIds: 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: safetyArchiveRecorder(deps, row),
     });
     const conflict = casTransition(deps, row, 'pr_closed', {
@@ -1397,6 +1400,7 @@ async function runCreatePr(deps, row) {
             db: deps.db, git: deps.git, repoDir: deps.project.path, worktreeIds: 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: safetyArchiveRecorder(deps, row),
         });
         if (patch.cleanupWarnings.length > 0)
@@ -1537,6 +1541,7 @@ async function runDiscard(deps, row, opts = { removeNeedsReview: true }) {
         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: safetyArchiveRecorder(deps, row),
     }));
     const retainedWorktreeBranches = new Set(snap.worktreeIds
@@ -1628,6 +1633,7 @@ async function runAcknowledgeNoChanges(deps, row) {
         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: safetyArchiveRecorder(deps, row),
     });
     // A fresh no-change branch is disposable only while Git still proves that it
@@ -1683,6 +1689,7 @@ async function settleMergedPr(deps, row) {
         worktreeIds: 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: safetyArchiveRecorder(deps, row),
     });
     await deleteOwnedBranchesIfUnchanged(deps, row, snap, cleanupWarnings);
@@ -2049,6 +2056,7 @@ async function runMergeLocalLocked(deps, row) {
         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: safetyArchiveRecorder(deps, row),
     }));
     await deleteOwnedBranchesIfUnchanged(deps, row, snap, cleanupWarnings);

package/server/dist/rail-worktree-release.js

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.durableBranchHeads = durableBranchHeads;
 exports.durableOverlayCleanupEvidence = durableOverlayCleanupEvidence;
+exports.durableSettlementIgnoredPaths = durableSettlementIgnoredPaths;
 exports.releaseRailWorktrees = releaseRailWorktrees;
 const rail_worktrees_store_1 = require("./rail-worktrees-store");
 const worktree_manager_1 = require("./worktree-manager");
@@ -104,6 +105,53 @@ function durableOverlayCleanupEvidence(records) {
     }
     return new Map([...byBranch].map(([branch, values]) => [branch, [...values.values()]]));
 }
+/** Collapse persisted settlement ignored-path snapshots per branch. The same
+ * conservative rules as overlay evidence: malformed paths, a failed capture
+ * (null), or conflicting per-branch snapshots grant NO authorization. */
+function durableSettlementIgnoredPaths(records) {
+    const byBranch = new Map();
+    for (const record of records) {
+        if (!record.branch || record.settlementIgnoredPaths === undefined)
+            continue;
+        const prior = byBranch.get(record.branch);
+        if (prior === null)
+            continue; // already poisoned
+        if (record.settlementIgnoredPaths === null) {
+            byBranch.set(record.branch, null);
+            continue;
+        }
+        if (!Array.isArray(record.settlementIgnoredPaths)) {
+            byBranch.set(record.branch, null);
+            continue;
+        }
+        const safe = [];
+        let valid = true;
+        for (const value of record.settlementIgnoredPaths) {
+            const normalized = typeof value === 'string' ? safeRelativeOverlayPath(value.replace(/\/$/, '')) : null;
+            if (!normalized) {
+                valid = false;
+                break;
+            }
+            safe.push(normalized);
+        }
+        if (!valid) {
+            byBranch.set(record.branch, null);
+            continue;
+        }
+        const sorted = [...new Set(safe)].sort();
+        if (prior === undefined) {
+            byBranch.set(record.branch, sorted);
+            continue;
+        }
+        if (prior.join('\0') !== sorted.join('\0'))
+            byBranch.set(record.branch, null);
+    }
+    return new Map([...byBranch].flatMap(([branch, paths]) => (paths === null ? [] : [[branch, paths]])));
+}
+function coveredBySnapshot(livePath, snapshot) {
+    const live = livePath.replace(/\/$/, '');
+    return snapshot.some((entry) => live === entry || live.startsWith(`${entry}/`));
+}
 async function verifyReleaseEvidence(input, worktree) {
     const expected = input.expectedHeadByBranch.get(worktree.branch)?.toLowerCase();
     if (!expected || !COMMIT_SHA_RE.test(expected)) {
@@ -117,10 +165,31 @@ async function verifyReleaseEvidence(input, worktree) {
             'status', '--porcelain', '--untracked-files=all', '--ignored=matching', '--', '.',
             ...overlayExcludes.map((entry) => `:(top,exclude,literal)${entry}`),
         ], worktree.worktree_path);
-        if (status.code !== 0)
+        if (status.code !== 0) {
+            if (!pathStillExists(worktree.worktree_path))
+                return { failure: null, overlayEntries: [], gone: true };
             return { failure: 'Git could not verify worktree cleanliness', overlayEntries: [] };
-        if (status.stdout.trim())
+        }
+        // Partition: tracked/untracked entries are unconditional dirt (unchanged
+        // strictness); gitignored entries are release-safe ONLY when the immutable
+        // settlement snapshot already contained them — run-created build caches
+        // release cleanly, anything ignored that APPEARED after settlement (a
+        // user-parked file) preserves the worktree exactly as before.
+        const statusLines = status.stdout.split('\n').map((line) => line.trimEnd()).filter(Boolean);
+        const dirtyLines = statusLines.filter((line) => !line.startsWith('!! '));
+        if (dirtyLines.length > 0)
             return { failure: 'the worktree contains changes made after settlement', overlayEntries: [] };
+        const ignoredPaths = statusLines.filter((line) => line.startsWith('!! ')).map((line) => line.slice(3));
+        if (ignoredPaths.length > 0) {
+            const snapshot = input.settlementIgnoredByBranch?.get(worktree.branch);
+            if (!snapshot) {
+                return { failure: 'the worktree contains ignored paths and no settlement snapshot authorizes them', overlayEntries: [] };
+            }
+            const uncovered = ignoredPaths.filter((livePath) => !coveredBySnapshot(livePath, snapshot));
+            if (uncovered.length > 0) {
+                return { failure: `the worktree contains ignored paths that appeared after settlement (${uncovered.slice(0, 3).join(', ')})`, overlayEntries: [] };
+            }
+        }
         const [head, branchRef] = await Promise.all([
             input.git.run(['rev-parse', '--verify', 'HEAD'], worktree.worktree_path),
             input.git.run(['rev-parse', '--verify', `refs/heads/${worktree.branch}`], input.repoDir),
@@ -136,6 +205,8 @@ async function verifyReleaseEvidence(input, worktree) {
         return { failure: null, overlayEntries };
     }
     catch (err) {
+        if (!pathStillExists(worktree.worktree_path))
+            return { failure: null, overlayEntries: [], gone: true };
         return { failure: `verification failed: ${err instanceof Error ? err.message : String(err)}`, overlayEntries: [] };
     }
 }
@@ -271,6 +342,21 @@ async function releaseRailWorktrees(input) {
         if (wt.merge_state !== 'needs-review' && (0, rail_worktrees_store_1.isTerminalMergeState)(wt.merge_state))
             continue;
         const evidence = await verifyReleaseEvidence(input, wt);
+        // The mount is already GONE (the user ran `git worktree remove` manually,
+        // or an external prune cleaned it): Git could not even inspect the path
+        // AND the filesystem confirms it is absent. There are no bytes left to
+        // preserve — failing verification forever would permanently block Checkout
+        // on a branch that is actually free. Prune the stale registration
+        // (best-effort; prune only drops entries whose dir is missing) and
+        // terminalize the ledger row honestly.
+        if (evidence.gone) {
+            try {
+                await input.git.run(['worktree', 'prune'], input.repoDir);
+            }
+            catch { /* a leftover registration surfaces at checkout with git's own error */ }
+            (0, rail_worktrees_store_1.updateRailWorktreeState)(input.db, wt.id, state);
+            continue;
+        }
         if (evidence.failure) {
             (0, rail_worktrees_store_1.updateRailWorktreeState)(input.db, wt.id, 'needs-review');
             const warning = `worktree ${wt.worktree_path}: preserved because ${evidence.failure}`;

package/server/dist/rails-router.js

@@ -21,6 +21,7 @@ const rail_isolation_1 = require("./rail-isolation");
 const rail_pr_store_1 = require("./rail-pr-store");
 const loop_effect_1 = require("./loop-effect");
 const rail_pr_decision_1 = require("./rail-pr-decision");
+const active_pr_continuation_1 = require("./active-pr-continuation");
 const rail_isolated_launch_1 = require("./rail-isolated-launch");
 const worktree_manager_1 = require("./worktree-manager");
 const rail_worktree_release_1 = require("./rail-worktree-release");
@@ -277,6 +278,40 @@ function createRailsRouter() {
             res.status(500).json({ error: 'Failed to update rail profile' });
         }
     });
+    // GET /rails/:railIndex/pr-candidates — display-only open-PR suggestions for
+    // the "deliver into existing PR" launch affordance. Reuses the automatic-
+    // continuation matchers WITHOUT the ticket-status gate: suggestions are
+    // informational, selection is always an explicit user action. No side effects.
+    router.get('/:railIndex/pr-candidates', async (req, res) => {
+        const c = ctx(req);
+        const railIndex = parseInt(req.params.railIndex, 10);
+        if (isNaN(railIndex) || railIndex < 0 || railIndex >= rails_store_1.MAX_RAILS) {
+            res.status(400).json({ error: 'Invalid rail index' });
+            return;
+        }
+        try {
+            const rail = (0, rails_store_1.getRail)(c.db, railIndex);
+            const candidates = await (0, active_pr_continuation_1.listPrCandidatesForTickets)({
+                db: c.db,
+                exec: pr_publisher_1.defaultExec,
+                repoDir: c.project.path,
+                ticketIds: [...(rail?.ticketIds ?? [])],
+                getTicketSpec: (ticketId) => {
+                    try {
+                        return c.getTicketSpec(ticketId) ?? undefined;
+                    }
+                    catch {
+                        return undefined;
+                    }
+                },
+            });
+            res.json({ candidates });
+        }
+        catch (err) {
+            console.error('[rails-router] pr-candidates error:', err);
+            res.status(500).json({ error: 'Failed to list PR candidates' });
+        }
+    });
     // PUT /rails/:railIndex/engine — set the AI engine override for a rail
     // Body: { aiEngine: string | null } (null = use the project's primary provider)
     router.put('/:railIndex/engine', (req, res) => {
@@ -352,7 +387,16 @@ function createRailsRouter() {
             return;
         }
         let { mode = 'implement' } = req.body ?? {};
-        const { profileName, aiEngine, model, loopId: rawLoopId, reasoning_effort, originConversationId, originSurface } = req.body ?? {};
+        const { profileName, aiEngine, model, loopId: rawLoopId, reasoning_effort, originConversationId, originSurface, targetPrNumber } = req.body ?? {};
+        // Explicit target PR (deliver-rail-into-existing-pr): the user names an
+        // existing open PR as the delivery destination. Shape-validated here;
+        // resolved and verified inside the isolated launch, fail-closed.
+        if (targetPrNumber !== undefined && targetPrNumber !== null) {
+            if (typeof targetPrNumber !== 'number' || !Number.isSafeInteger(targetPrNumber) || targetPrNumber <= 0 || targetPrNumber > 1_000_000_000) {
+                res.status(400).json({ error: 'invalid_target_pr', detail: 'targetPrNumber must be a positive integer' });
+                return;
+            }
+        }
         let loopId = rawLoopId;
         // Origin link (safe-pr-review-flow): an agent-chat/MCP launch tags itself so
         // the PR decision can later be posted back into the launching conversation.
@@ -395,6 +439,13 @@ function createRailsRouter() {
             res.status(403).json({ error: 'Loops are disabled on this server' });
             return;
         }
+        // An explicit target PR is only meaningful on the isolated PR-delivery
+        // path. Reject early when that path is structurally unavailable rather
+        // than silently launching fresh work next to the designated PR.
+        if (typeof targetPrNumber === 'number' && (!(0, feature_flags_1.isLoopsEnabled)() || !(0, rail_isolation_1.isRailPrDeliveryEnabled)())) {
+            res.status(400).json({ error: 'target_pr_requires_pr_mode', detail: 'targetPrNumber requires loops and PR delivery to be enabled' });
+            return;
+        }
         // Freestyle model picker: optional, validated against the allow-list.
         // Ignored for non-freestyle modes (they use the orchestrator model).
         if (mode === 'freestyle' && model !== undefined && model !== null) {
@@ -571,11 +622,23 @@ function createRailsRouter() {
                         res.status(409).json({ error: 'pr_decision_pending', prDeliveryId: pendingSnapshot.id });
                         return;
                     }
+                    // Explicit target vs an undecided continuable delivery: the slot's
+                    // active generation owns its PR. A DIFFERENT explicit target would
+                    // append to the undecided branches → 409; the SAME PR is redundant
+                    // (the continuation contract below already drives it) and is dropped.
+                    if (pendingSnapshot && typeof targetPrNumber === 'number' && pendingSnapshot.prNumber !== targetPrNumber) {
+                        res.status(409).json({ error: 'pr_decision_pending', prDeliveryId: pendingSnapshot.id });
+                        return;
+                    }
                     continuablePrDelivery = pendingSnapshot;
                 }
                 const useIsolation = (0, rail_isolation_1.isolationApplies)({
                     loopsEnabled: (0, feature_flags_1.isLoopsEnabled)(), scope, ticketCount: rail.ticketIds.length, readOnly: loopReadOnly,
                 });
+                if (typeof targetPrNumber === 'number' && !useIsolation) {
+                    res.status(400).json({ error: 'target_pr_requires_pr_mode', detail: 'targetPrNumber requires an isolated (worktree) launch; this launch would run in the shared checkout' });
+                    return;
+                }
                 if (continuablePrDelivery && !loopReadOnly && !useIsolation) {
                     res.status(409).json({
                         error: 'pr_continuation_isolation_required',
@@ -589,6 +652,13 @@ function createRailsRouter() {
                     // unborn HEAD can't be branched). Fall back (with a message) otherwise.
                     const status = await (0, worktree_manager_1.repoIsolationStatus)(worktree_manager_1.defaultGitRunner, c.project.path);
                     if (status !== 'ok') {
+                        if (typeof targetPrNumber === 'number') {
+                            res.status(400).json({
+                                error: 'target_pr_requires_pr_mode',
+                                detail: `targetPrNumber requires worktree isolation, which is unavailable (${status})`,
+                            });
+                            return;
+                        }
                         if (continuablePrDelivery) {
                             res.status(409).json({
                                 error: 'pr_continuation_isolation_required',
@@ -618,6 +688,12 @@ function createRailsRouter() {
                                         deliverySha: continuablePrDelivery.deliverySha,
                                     },
                                 } : {}),
+                                // Explicit target only drives fresh launches; when the slot has
+                                // a continuable delivery for the same PR, the continuation
+                                // contract above is the (stricter) authority.
+                                ...(typeof targetPrNumber === 'number' && !continuablePrDelivery
+                                    ? { explicitPrTarget: { prNumber: targetPrNumber } }
+                                    : {}),
                             });
                             res.status(202).json({ loopRunIds: ids, railIndex, mode, isolated: true });
                             return;
@@ -630,6 +706,16 @@ function createRailsRouter() {
                                 });
                                 return;
                             }
+                            // Explicit-target validation failures are the USER's answer being
+                            // unusable — fail closed with the machine-readable code; never
+                            // fall back to a fresh shared-cwd run next to the designated PR.
+                            if (err instanceof active_pr_continuation_1.ExplicitPrTargetError) {
+                                res.status(err.code === 'target_pr_not_found' ? 404 : 409).json({
+                                    error: err.code,
+                                    detail: err.message,
+                                });
+                                return;
+                            }
                             if (continuablePrDelivery || err instanceof rail_isolated_launch_1.PrContinuationIsolationError) {
                                 const detail = err instanceof Error ? err.message : String(err);
                                 res.status(409).json({
@@ -1052,6 +1138,7 @@ function createRailsRouter() {
                     worktreeIds: currentSnap.worktreeIds,
                     expectedHeadByBranch: (0, rail_worktree_release_1.durableBranchHeads)(currentSnap.branches),
                     overlayEvidenceByBranch: (0, rail_worktree_release_1.durableOverlayCleanupEvidence)(currentSnap.branches),
+                    settlementIgnoredByBranch: (0, rail_worktree_release_1.durableSettlementIgnoredPaths)(currentSnap.branches),
                     onSafetyArchive: (archive) => {
                         archived = true;
                         if (!(0, rail_pr_store_1.appendPrDeliverySafetyArchive)(c.db, row.id, archive)) {
@@ -1077,6 +1164,17 @@ function createRailsRouter() {
                         detail: cleanupWarnings[0],
                     };
                 }
+                // Cleanup just completed with ZERO warnings — clear any stale
+                // cleanup_incomplete evidence persisted by earlier failed release
+                // attempts, so the card stops claiming "Cleanup is incomplete" after
+                // the condition has been resolved. Same-state patch + live broadcast.
+                if (currentSnap.cleanupWarnings.length > 0 || currentSnap.statusCode === 'cleanup_incomplete') {
+                    (0, rail_pr_store_1.transitionDecision)(c.db, row.id, currentSnap.decision, currentSnap.decision, {
+                        cleanupWarnings: [],
+                        ...(currentSnap.statusCode === 'cleanup_incomplete' ? { statusCode: null } : {}),
+                    });
+                    emitPrDeliveryUpdate(c, row.id);
+                }
                 const checkedOut = await (0, project_git_1.checkoutProjectReviewBranch)(c.project.path, currentSnap.branch, currentSnap.deliverySha);
                 if (!checkedOut.ok) {
                     return { ok: false, status: 409, error: 'checkout_failed', detail: checkedOut.error };

package/server/dist/worktree-manager.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PR_NEVER_STAGE_PATHS = exports.defaultGitRunner = void 0;
+exports.PR_NEVER_STAGE_PATHSPEC_ROOTS = exports.PR_NEVER_STAGE_PATHS = exports.defaultGitRunner = void 0;
 exports.isGitRepo = isGitRepo;
 exports.repoIsolationStatus = repoIsolationStatus;
 exports.worktreeBranch = worktreeBranch;
@@ -243,7 +243,7 @@ async function gitRun(git, args, cwd) {
 function commitPathspecs(excludePaths) {
     return [
         '--', '.',
-        ...exports.PR_NEVER_STAGE_PATHS.map((p) => `:(exclude)${p}`),
+        ...exports.PR_NEVER_STAGE_PATHSPEC_ROOTS.map((p) => `:(exclude)${p}`),
         // Overlay names originate in the workspace filesystem. Treat them as
         // literal top-level paths so glob/pathspec metacharacters cannot broaden
         // the never-commit surface.
@@ -261,6 +261,23 @@ function normalizedGitPath(value) {
 function isPathAtOrBelow(candidate, root) {
     return candidate === root || candidate.startsWith(`${root}/`);
 }
+/**
+ * Collapse a path list to its minimal roots — drop any entry that is at or
+ * below another. Overlay-owned entries like `.claude/agent-memory` are
+ * SYMLINKS (the overlay links shared memory in). A git pathspec that descends
+ * INTO a symlink — `:(exclude).claude/agent-memory/**` or the `/explanations`
+ * subpaths — is rejected with `fatal: pathspec ... is beyond a symbolic link`,
+ * which aborts the entire `git add`/`git status` and blocks PR delivery. The
+ * symlink ROOT alone (`:(exclude).claude/agent-memory`) still excludes all of
+ * its contents (dir-level pathspec semantics) without traversing the link, and
+ * is equally correct for the copy-fallback case where it is a real directory.
+ */
+function minimalPathRoots(paths) {
+    const norm = [...new Set(paths.map((p) => (p.endsWith('/**') ? p.slice(0, -3) : p)))];
+    return norm.filter((p) => !norm.some((other) => other !== p && isPathAtOrBelow(p, other)));
+}
+/** Symlink-safe never-stage pathspec roots (see {@link minimalPathRoots}). */
+exports.PR_NEVER_STAGE_PATHSPEC_ROOTS = minimalPathRoots(exports.PR_NEVER_STAGE_PATHS);
 function forbiddenStagedPaths(staged, excludePaths) {
     const overlayRoots = excludePaths.map(normalizedGitPath).filter(Boolean);
     return staged.filter((candidate) => (PR_NEVER_STAGE_ROOTS.some((root) => isPathAtOrBelow(candidate, root))
@@ -307,7 +324,17 @@ function describeForbiddenPaths(paths) {
  */
 async function commitWorktreeAndVerify(git, worktreePath, message, excludePaths = []) {
     const pathspecs = commitPathspecs(excludePaths);
-    const add = await gitRun(git, ['add', '-A', ...pathspecs], worktreePath);
+    // The add is deliberately PLAIN — no exclude pathspecs. `git add` exits 1
+    // with "The following paths are ignored by one of your .gitignore files"
+    // whenever ANY pathspec item (exclude items included) names a git-ignored
+    // path, and our own info/exclude block (ensurePrNeverStageExcludes) plus repo
+    // .gitignore entries (e.g. `.claude/settings.local.json`) make exactly the
+    // excluded paths ignored. Ignored paths can never be staged without `-f`, so
+    // the plain add is safe for them; non-ignored overlay files DO get staged
+    // here and are unstaged by the audit → reset flow below before the commit,
+    // whose `--only` pathspecs (which git commit accepts without the
+    // ignored-path check) remain the authoritative exclusion.
+    const add = await gitRun(git, ['add', '-A', '--', '.'], worktreePath);
     let indexSafe = false;
     let indexError;
     if (add.code === 0) {
@@ -319,8 +346,8 @@ async function commitWorktreeAndVerify(git, worktreePath, message, excludePaths
             indexSafe = true;
         }
         else {
-            // Exclude pathspecs prevent newly-staged private/overlay files, but an
-            // earlier process may already have put them in the index. Reset only the
+            // The plain add routinely stages non-ignored overlay files, and an
+            // earlier process may have put private paths in the index. Reset only the
             // prohibited roots back to HEAD: working files remain intact for recovery.
             const reset = await gitRun(git, ['reset', '--quiet', ...forbiddenResetPathspecs(excludePaths)], worktreePath);
             if (reset.code !== 0) {

package/client/dist/assets/dashboard-BmDZmHyY.js

@@ -1 +0,0 @@
-import{r as e}from"./rolldown-runtime-CNC7AqOf.js";var t=e({default:()=>d,freestyleDialog:()=>l,launchAll:()=>a,launchAllDialog:()=>o,railControls:()=>s,railPr:()=>r,railRow:()=>c,railsBoard:()=>i,toasts:()=>n,useRails:()=>u}),n={railAdded:`Rail {{n}} added`,railRemoved:`{{rail}} removed`,railLimitReached:`Rail limit reached ({{max}} max)`,railDeleteFailed:`Couldn't remove the rail — it holds specs, is running, or has a pending PR decision`,launchTicketsInFlight:`A spec on this rail is already being worked by an active run`,launchAllSummary_one:`{{count}} rail launched in parallel`,launchAllSummary_other:`{{count}} rails launched in parallel`,launchAllNoneEligible:`No rails ready to launch — assign specs to an idle rail first`,launchAllFailed:`No rails could be launched`,railCompleted:`Rail {{n}} completed`,railFailed:`Rail {{n}} failed — specs returned to Specs`,railEnded:`Rail {{n}} {{status}} — specs returned to Specs`,alreadyOnRail:`Already on {{rail}}`,movedToRail:`Moved to {{rail}}`,railRunningStopFirst:`{{rail}} is running — stop it before removing`,removedFromRail:`Removed from {{rail}}`,queuedOnRail:`Queued on {{rail}}`,queuedOnRailDescription:`Rail is currently running`,railStopped:`{{rail}} stopped`,stopFailed:`Failed to stop rail`,syncTicketsFailed:`Failed to sync rail tickets`,launchFailed:`Failed to launch rail`,launchNetworkError:`Network error launching rail`,railLaunched:`{{rail}} launched`,launchDescription_one:`{{mode}} with {{count}} spec`,launchDescription_other:`{{mode}} with {{count}} specs`,railWorktreeNeedsReview:`Rail {{n}}: spec #{{ticket}} needs review after merge`,railWorktreesNoGit:`Worktree isolation unavailable: this project isn't a git repository — running in shared mode.`,railWorktreesNoCommits:`Worktree isolation unavailable: the repository has no commits yet — make an initial commit, then relaunch.`,railWorktreesError:`Worktree isolation failed — this run continues WITHOUT the PR review flow (no implementation card). See the error detail below.`,onReviewCannotMoveToRail:`This spec is awaiting PR review — resolve the PR decision first`,onReviewNotLaunchable:`A spec on this rail is awaiting PR review — resolve the PR decision before launching`},r={operation:{inProgress:`Action in progress…`,"create-pr":`Creating PR…`,publish:`Publishing…`,discard:`Discarding…`,dismiss:`Dismissing follow-up…`,"poll-merge":`Checking merge…`,reopen:`Reopening…`,"merge-local":`Integrating locally…`,"recover-and-retry":`Committing and retrying the preserved result…`,"acknowledge-no-changes":`Marking done…`},readyForReview:`Ready for review`,draftPr:`Draft PR`,branchPushed:`Branch pushed — PR pending`,branchPushedHint:`The branch was pushed but the PR couldn't be created (GitHub CLI unavailable). Retry to create it.`,localOnly:`Changes available locally`,localOnlyHint:`The implementation completed, but the changes have not been pushed. Integrate them locally or retry publishing when the remote is available.`,noChanges:`No changes needed`,markDone:`Mark done`,refine:`Refine`,completedToast:`Confirmed — specs moved to Done`,markDoneConfirmTitle:`Mark these specs done?`,markDoneConfirmBody:`The implementation confirmed that no code changes are needed. The specs will move to Done and the no-change worktree will be cleaned up.`,refineConfirmTitle:`Refine these specs?`,refineConfirmBody:`The no-change result will be closed and the specs will return to the backlog so you can refine them. The run logs remain available.`,partial:`{{succeeded}} of {{total}} implementations ready`,createPartialPr:`Create PR with {{count}}`,deliveryBlocked:`Implementation complete — delivery needs attention`,updateFailed:`Implementation complete — update failed`,retryPush:`Retry push`,retryPushVerified:`Push verified · commit {{sha}} is in the PR`,commitAlreadyVerified:`Commit {{sha}} is already verified in the PR`,deliveryCommit:`commit {{sha}}`,prClosed:`PR closed without merge`,reopen:`Reopen`,iteratingPr:`Updating PR`,prReady:`PR ready`,implementationFailed:`Implementation failed`,implementationFailedHint:`The implementation run failed. Open the run log, then discard this card before relaunching.`,prFailed:`PR failed`,prFailedDetail:`PR failed: {{detail}}`,createDegraded:`Couldn't publish the PR — {{detail}}. Retry when resolved.`,createPr:`Create PR`,createPrTooltip:`→ {{base}}`,publish:`Publish`,publishTooltip:`Open this draft PR for team review`,checkout:`Checkout`,checkoutTooltip:`Check out {{branch}} in the main project folder`,checkoutSuccess:`Checked out {{branch}}`,checkoutFailed:`Could not check out the PR branch`,checkoutDirtyTitle:`Checkout blocked to protect your changes`,checkoutDirtyBody:`The main project folder has uncommitted changes. Commit or stash them, then retry. Nothing was changed.`,checkoutSafetyUnknownTitle:`Checkout paused because safety could not be verified`,checkoutSafetyUnknownBody:`Specrails could not read the main project folder’s Git status. Nothing was released or changed. Retry after Git is available.`,checkoutNotDeliverableTitle:`This PR branch is not the preserved implementation`,checkoutNotDeliverableBody:`No exact delivery commit has been verified yet. Inspect or recover the local result instead.`,inspectLocalResult:`Inspect local result`,inspectLocalResultTooltip:`Reveal the preserved isolated worktree and copy its path`,localResultPathCopied:`Local result path copied`,localResultPath:`Preserved local result`,localResultUnavailableHere:`No recoverable worktree is available on this computer. Review the run log from the machine where it executed.`,recoverAndRetry:`Commit & retry push`,recoverAndRetryConfirmTitle:`Commit and push the preserved result?`,recoverAndRetryConfirmBody:`Specrails will use only the isolated worktree or recorded fast-forward branch for {{branch}}. It will commit deliverable files if needed, then push the exact commit only if the PR is still open on the expected head and base. Your main project folder and its uncommitted changes will not be touched.`,recoverAndRetryVerified:`Recovered commit {{sha}} is verified in the PR`,recoveryStillBlocked:`Local recovery still needs attention`,recheckRecovery:`Check again`,recheckRecoveryConfirmTitle:`Check this computer again?`,recheckRecoveryConfirmBody:`Specrails will rescan this clone’s delivery-owned worktree, branch, refs, reflogs, and orphan Git objects for {{branch}}. If it proves one result, it may commit isolated changes and retry the exact push. Your main project folder will not be touched.`,recoveryUnavailable:`Recovery could not be verified on this computer`,recoveryUnavailableBody:`Specrails could not safely prove one delivery-owned result in this clone. Nothing was changed or removed. Inspect the stage detail and run logs. If the run executed on another computer, open Specrails there, then check again.`,recoveryDetailSummary:`Technical recovery detail`,discard:`Discard`,dismiss:`Dismiss follow-up`,discardLocalResult:`Discard local result`,discardTooltip:`Close the delivery and return its tickets to Specs; changed local work is preserved`,retryPr:`Retry PR`,retry:`Retry`,checkMerge:`Check merge`,verifyPr:`Verify PR`,verifyPrTooltip:`Verify the exact commit in GitHub and check whether the PR is merged`,checkMergeTooltip:`Ask GitHub whether the PR has been merged`,prLinkFallback:`PR`,openPrTitle:`Open the PR on GitHub`,notMergedYet:`Not merged yet`,commitMissingRetry:`The delivery commit is no longer in the PR. Retry push is available again.`,prVerifiedWaiting:`Commit {{sha}} verified · waiting for merge`,alreadyResolved:`Already resolved elsewhere`,ghFailed:`GitHub CLI failed: {{detail}}`,actionFailed:`Couldn't apply the PR decision`,mergedToast:`PR merged — tickets moved to Done`,discardedToast:`PR discarded — tickets returned to Specs`,decisionPending:`This rail has a pending PR decision — create, publish or discard it before relaunching`,discardConfirmTitle:`Discard this delivery?`,discardConfirmBody:`The PR will be closed without deleting its remote branch. Only SpecRails-owned local branches and worktrees that are still at their recorded commit will be removed; anything changed will be preserved with a warning. The tickets will return to the Specs backlog. Removed local resources cannot be recovered.`,implementationFailedDiscardTitle:`Discard this failed delivery?`,implementationFailedDiscardBody:`The card will be cleared and its tickets will return to Specs. Local work and branches will be kept for inspection. Only resources proven safe to clean up may be removed.`,dismissConfirmTitle:`Dismiss this follow-up?`,dismissConfirmBody:`This follow-up card will be cleared. Its owned worktree will be removed only if it is still safe; otherwise it will be preserved with a warning. The existing PR, its branch, and review state will remain unchanged.`,discardLocalConfirmTitle:`Discard the local result?`,discardLocalConfirmBody:`The recoverable local iteration will be removed only if it is still safe; if it changed, it will be preserved with a warning. Any existing PR and its branch will remain unchanged. A removed result cannot be recovered.`,mergeLocal:`Integrate locally`,mergeLocalTooltip:`Merge the delivered branches into {{base}} in your local checkout (no GitHub needed)`,mergeLocalConfirmTitle:`Integrate locally?`,mergeLocalConfirmBody:`The delivered branches will be merged into {{base}} in your local checkout. Your checkout must be on {{base}} with a clean working tree.`,mergeLocalBlockedDirty:`Cannot integrate: your working tree on {{base}} has uncommitted changes. Commit or stash them, then retry.`,mergeLocalBlockedBranch:`Cannot integrate: your checkout is on {{current}}, not {{base}}. Check out {{base}}, then retry.`,mergeLocalFailed:`Local merge failed: {{detail}}`,mergedLocally:`Integrated into {{base}} locally`,viewRunLog:`View run log for {{ref}}`,cleanupIncomplete_one:`Cleanup is incomplete ({{count}} warning)`,cleanupIncomplete_other:`Cleanup is incomplete ({{count}} warnings)`,cleanupIncompleteHint:`Local recovery data was preserved. Inspect these details before removing anything manually.`,copyCleanupDetails:`Copy recovery details`,safetyArchiveTitle:`Safety archive ({{count}})`,safetyArchiveHint:`Temporary workspace files were preserved outside the PR as a precaution. You can inspect or remove them manually.`,copySafetyArchive:`Copy paths`,unit:{failed:`implementation failed`,blocked:`delivery blocked`,noChanges:`no changes`,succeeded:`ready`}},i={title:`Rails`,runningCount_one:`{{count}} running`,runningCount_other:`{{count}} running`,launchAll:`Launch all`,launchAllTitle:`Launch every ready rail in parallel — each run is isolated in its own git worktree`},a={skipRunning_one:`{{count}} already running`,skipRunning_other:`{{count}} already running`,skipEmpty_one:`{{count}} without specs`,skipEmpty_other:`{{count}} without specs`,skipPendingDecision_one:`{{count}} awaiting a PR decision`,skipPendingDecision_other:`{{count}} awaiting a PR decision`,skipOnReview_one:`{{count}} with specs on review`,skipOnReview_other:`{{count}} with specs on review`,skipInFlight_one:`{{count}} skipped (spec already in flight)`,skipInFlight_other:`{{count}} skipped (specs already in flight)`,failedCount_one:`{{count}} failed`,failedCount_other:`{{count}} failed`},o={title:`Launch all rails`,railsCount_one:`{{count}} rail`,railsCount_other:`{{count}} rails`,specsCount_one:`{{count}} spec`,specsCount_other:`{{count}} specs`,isolationTitle:`Parallel & isolated.`,isolationBody:`Each rail runs in its own git worktree — concurrent launches never collide.`,pipelinesTitle_one:`{{count}} AI pipeline.`,pipelinesTitle_other:`{{count}} AI pipelines.`,pipelinesBody:`One launch per rail, each with its configured mode, engine and profile.`,costTitle:`Multiplied cost.`,costBody:`Every rail spawns its own AI run — spend scales with the number of rails.`,launch_one:`Launch {{count}} rail`,launch_other:`Launch {{count}} rails`},s={viewJobLog:`View job log`,log:`Log`,implement:`Implement`,batch:`Batch`,freestyle:`Freestyle`,freestyleTitle:`Freestyle — Claude implements the spec autonomously, no pipeline`,loop:`Loop`,loopTitle:`Loop — run a published automation loop against the rail's specs`,pickLoop:`Pick a loop…`,effortTitle:`Reasoning effort`,stop:`Stop`,play:`Play`,failedRetry:`Job failed — click to retry`,addSpecsFirst:`Add specs to this rail first`,builtInLoops:`Built-in`,customLoops:`Custom loops`,worktreesMerged:`{{count}} merged`,worktreesNeedsReview:`{{count}} need review`,execSteps:`{{count}} steps`,execLines:`{{count}} lines`,openspec:`OpenSpec`},c={moveToSpecs:`Move to Specs`,deleteRail:`Delete {{label}}`,dropHere:`Drop here`,dropOnThisRail:`Drop on this rail`,dragSpecsHere:`Drag specs here`},l={title:`Launch in Freestyle mode`,context_one:`{{rail}} · {{count}} spec`,context_other:`{{rail}} · {{count}} specs`,noPipelineTitle:`No OpenSpec pipeline.`,noPipelineBody:`The structured architect → developer → reviewer flow is skipped entirely.`,autonomyTitle:`Native Claude autonomy.`,autonomyBody:`Claude works on its own using native agents and dynamic workflows.`,costTitle:`Variable cost.`,costBody:`Spend depends on what Claude decides to do — it can be higher than expected.`,continue:`Continue`},u={fetchFailed:`Failed to fetch rails: {{status}}`},d={toasts:n,railPr:r,railsBoard:i,launchAll:a,launchAllDialog:o,railControls:s,railRow:c,freestyleDialog:l,useRails:u};export{t};