specrails-desktop 2.34.0 → 2.34.1

package/client/dist/index.html

@@ -204,7 +204,7 @@
         .specrails-splash__mark .pill { opacity: 1; }
       }
     </style>
-    <script type="module" crossorigin src="/assets/index-C_sdsSZt.js"></script>
+    <script type="module" crossorigin src="/assets/index-DdC_faQv.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/rolldown-runtime-CNC7AqOf.js">
     <link rel="modulepreload" crossorigin href="/assets/jsx-runtime-zu2_FqZY.js">
     <link rel="modulepreload" crossorigin href="/assets/react-dom-DiWzBDP9.js">
@@ -277,7 +277,7 @@
     <link rel="modulepreload" crossorigin href="/assets/getTimezoneOffsetInMilliseconds-EjGOpn4b.js">
     <link rel="modulepreload" crossorigin href="/assets/formatDistanceToNow-BOuXgebD.js">
     <link rel="modulepreload" crossorigin href="/assets/spending-BpYPsevQ.js">
-    <link rel="modulepreload" crossorigin href="/assets/TicketDetailModal-MhJzrqbi.js">
+    <link rel="modulepreload" crossorigin href="/assets/TicketDetailModal-BPaqyvrs.js">
     <link rel="stylesheet" crossorigin href="/assets/index-DCN5QbDm.css">
   </head>
   <body>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "specrails-desktop",
-  "version": "2.34.0",
+  "version": "2.34.1",
   "license": "MIT",
   "repository": {
     "type": "git",

package/server/dist/providers/claude-adapter.js

@@ -12,6 +12,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.claudeAdapter = void 0;
 exports._normaliseClaudeModel = normaliseModel;
+exports._resolveClaudeSpawnModel = resolveSpawnModel;
 const child_process_1 = require("child_process");
 const path_1 = __importDefault(require("path"));
 const WHICH_CMD = process.platform === 'win32' ? 'where' : 'which';
@@ -33,6 +34,7 @@ function normaliseModel(model) {
             return 'sonnet';
         case 'claude-fable-5':
             return 'fable';
+        case 'claude-opus-5':
         case 'claude-opus-4-8':
         case 'claude-opus-4-5':
         case 'claude-opus-4-1-20250805':
@@ -46,6 +48,24 @@ function normaliseModel(model) {
             return model || 'sonnet';
     }
 }
+/**
+ * Catalog aliases whose GENERATION Specrails pins explicitly.
+ *
+ * The catalog value (`opus`) stays the stored, validated and displayed identity
+ * — profiles, project settings, conversation rows and analytics all keep using
+ * it, and `normaliseModel` collapses the pinned id back to it. Only the spawn
+ * argument is expanded, so picking "Claude Opus" is a product decision about
+ * WHICH Opus runs instead of delegating that to whatever generation the CLI's
+ * bare `opus` alias currently points at.
+ */
+const PINNED_ALIAS_MODEL_IDS = {
+    opus: 'claude-opus-5',
+};
+/** Catalog value (or concrete id) in, spawn model id out. */
+function resolveSpawnModel(model) {
+    const alias = normaliseModel(model);
+    return PINNED_ALIAS_MODEL_IDS[alias] ?? alias;
+}
 /**
  * Common flags + the effective tool boundary for this spawn.
  *
@@ -95,7 +115,7 @@ function commonFlagsFor(opts) {
 }
 function buildClaudeArgs(action, opts) {
     const args = [];
-    const model = normaliseModel(opts.model);
+    const model = resolveSpawnModel(opts.model);
     // Titles are unconditionally pure-output. Centralising the policy here keeps
     // both ChatManager and AgentChatManager from accidentally regaining tools.
     const commonFlags = commonFlagsFor(action === 'auto-title' ? { ...opts, toolPolicy: 'none' } : opts);

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

@@ -301,7 +301,7 @@ function branchRecords(results) {
         branchOwnership: result.run.branchOwnership,
         worktreePath: result.run.handle.worktreePath,
         overlayExcludes: result.run.overlayExcludes,
-        overlayCleanupEvidence: result.run.overlayCleanupEvidence,
+        overlayCleanupEvidence: [...result.run.overlayCleanupEvidence, ...result.run.warmLinkEvidence],
         settlementIgnoredPaths: result.run.settlementIgnoredPaths ?? null,
     })));
 }
@@ -695,10 +695,17 @@ async function launchIsolatedRail(input, io = {}) {
                         // into the fresh worktree (best-effort; a failure just leaves the run
                         // on the legacy cold start). Linked paths join the overlay exclusion
                         // list so they inherit the commit-time guarantees.
+                        let warmLinkEvidence = [];
                         try {
                             const nm = (io.linkNodeModules ?? worktree_node_modules_1.linkNodeModulesIntoWorktree)(baseRepo, handle.worktreePath);
-                            if (nm.linked.length > 0)
-                                overlayExcludes = overlayExcludes.concat(nm.linked);
+                            // `authenticated` (not `linked`) is the authorized set: it also covers
+                            // links a previous pass created, which a resumed launch would
+                            // otherwise leave both un-excluded from the commit and unauthorized
+                            // for release.
+                            const authorized = nm.authenticated ?? nm.linked ?? [];
+                            if (authorized.length > 0)
+                                overlayExcludes = overlayExcludes.concat(authorized);
+                            warmLinkEvidence = nm.evidence ?? [];
                             if (nm.warnings.length > 0)
                                 notifyOverlayDegraded(unit.ticketId, nm.warnings);
                         }
@@ -732,6 +739,7 @@ async function launchIsolatedRail(input, io = {}) {
                             handle,
                             overlayExcludes,
                             overlayCleanupEvidence,
+                            warmLinkEvidence,
                             provenanceSnapshot,
                             continuationTarget,
                             baseRef: continuationTarget?.baseRef ?? worktreeBaseRef.baseRef,
@@ -876,6 +884,13 @@ async function launchIsolatedRail(input, io = {}) {
                 instructionsFilename: overlayInstructions,
             }, a.overlayCleanupEvidence);
         }
+        // Warm-dependency links are re-proven against the base repo (their source),
+        // not the framework overlay source. A link the engine replaced with a real
+        // install loses its authorization here and correctly preserves the worktree.
+        if (a.warmLinkEvidence.length > 0) {
+            a.warmLinkEvidence = (0, worktree_node_modules_1.authenticateWarmNodeModulesLinks)(baseRepo, a.handle.worktreePath)
+                .filter((live) => a.warmLinkEvidence.some((prior) => prior.path === live.path && prior.kind === live.kind && prior.digest === live.digest));
+        }
         let commit;
         try {
             commit = await (0, worktree_manager_1.commitWorktreeAndVerify)(git, a.handle.worktreePath, worktreeCommitMessage(ctx, a.ticketId, a.runId, implementationOutcome === 'failed'), a.overlayExcludes);

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

@@ -42,6 +42,7 @@ const worktree_manager_1 = require("./worktree-manager");
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
 const worktree_overlay_1 = require("./worktree-overlay");
+const worktree_node_modules_1 = require("./worktree-node-modules");
 const COMMIT_SHA_RE = /^[0-9a-f]{40,64}$/i;
 /** Collapse per-unit settlement evidence into one unambiguous immutable HEAD per
  * branch. Conflicting or malformed records intentionally yield no authorization. */
@@ -157,8 +158,23 @@ async function verifyReleaseEvidence(input, worktree) {
     if (!expected || !COMMIT_SHA_RE.test(expected)) {
         return { failure: 'no durable settled HEAD is recorded for its branch', overlayEntries: [] };
     }
-    const overlayEntries = (input.overlayEvidenceByBranch.get(worktree.branch) ?? [])
+    const persistedEntries = (input.overlayEvidenceByBranch.get(worktree.branch) ?? [])
         .filter((entry) => (0, worktree_overlay_1.matchesOverlayCleanupEvidence)(worktree.worktree_path, entry));
+    // Warm-dependency links are authenticated LIVE against the base repo, on top
+    // of whatever was persisted. Two reasons this is derived and not persisted-
+    // only: a repo's ordinary `node_modules/` DIRECTORY ignore pattern does not
+    // ignore a SYMLINK of that name, so the link reads as untracked dirt and
+    // permanently blocked release (and therefore branch checkout); and worktrees
+    // that settled before the links carried evidence are stuck at `needs-review`
+    // where no persisted fix could ever reach them. The proof is identical to the
+    // persisted one — a symlink resolving to the base checkout's identically-
+    // named dependency directory — so nothing weaker is being accepted here.
+    const warmEntries = (input.authenticateWarmLinks ?? worktree_node_modules_1.authenticateWarmNodeModulesLinks)(input.repoDir, worktree.worktree_path);
+    const seenPaths = new Set(persistedEntries.map((entry) => entry.path));
+    const overlayEntries = [
+        ...persistedEntries,
+        ...warmEntries.filter((entry) => !seenPaths.has(entry.path)),
+    ];
     const overlayExcludes = overlayEntries.map((entry) => entry.path);
     try {
         const status = await input.git.run([

package/server/dist/worktree-node-modules.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isWorktreeNodeModulesEnabled = isWorktreeNodeModulesEnabled;
+exports.authenticateWarmNodeModulesLinks = authenticateWarmNodeModulesLinks;
 exports.linkNodeModulesIntoWorktree = linkNodeModulesIntoWorktree;
 /**
  * Warm-dependency reuse for isolated rail worktrees.
@@ -57,10 +58,26 @@ exports.linkNodeModulesIntoWorktree = linkNodeModulesIntoWorktree;
  *    prior link, anything) is left untouched, so resume passes are idempotent
  *    and an agent-made install is never clobbered.
  *
- * The returned `linked` paths are appended to the launch's overlay-exclusion
- * list, so a linked `node_modules` inherits the same commit-time guarantees as
- * overlay scaffolding (excluded pathspecs + index audit) even if the repo's
- * `.gitignore` were ever missing the entry.
+ * The returned `authenticated` paths are appended to the launch's overlay-
+ * exclusion list, so a linked `node_modules` inherits the same commit-time
+ * guarantees as overlay scaffolding (excluded pathspecs + index audit) even if
+ * the repo's `.gitignore` were ever missing the entry.
+ *
+ * Release safety (why `authenticated` exists next to `linked`): a repo whose
+ * `.gitignore` carries the ordinary `node_modules/` DIRECTORY pattern does not
+ * ignore a SYMLINK named `node_modules`, so the link surfaces as an untracked
+ * entry in `git status`. Without evidence authorizing it, worktree release read
+ * that as "the worktree contains changes made after settlement", parked the row
+ * at `needs-review` forever and permanently blocked checkout of the branch. The
+ * links therefore also carry `OverlayCleanupEvidence`, and a link created by an
+ * EARLIER pass (resume) is re-authenticated instead of being ignored — the old
+ * `linked`-only contract silently dropped both guarantees on resume.
+ *
+ * Authentication is deliberately narrow and source-anchored, never name-based:
+ * the worktree entry must be a symlink whose resolved target is exactly the base
+ * checkout's identically-named dependency directory. A real directory, a copy,
+ * or a link pointing anywhere else stays unauthorized and preserves the
+ * worktree, as `Recoverable work is never removed automatically` requires.
  *
  * Honest caveat (documented, accepted): the link SHARES the dependency tree
  * with the base checkout. Reads (tests, builds) are safe under concurrency; an
@@ -72,8 +89,11 @@ exports.linkNodeModulesIntoWorktree = linkNodeModulesIntoWorktree;
  */
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const worktree_overlay_1 = require("./worktree-overlay");
 /** Package-dir discovery depth: 0 = repo root, 1 = `client/`-style children. */
 const MAX_DEPTH = 2;
+/** Name of the dependency directory this module links. */
+const DEPS_DIR = 'node_modules';
 function isWorktreeNodeModulesEnabled() {
     return (process.env.SPECRAILS_WORKTREE_NODE_MODULES ?? '').toLowerCase() !== 'false';
 }
@@ -127,31 +147,133 @@ function discoverPackageDirs(baseRepo) {
     walk('', 0);
     return found;
 }
+/** Resolve a path through symlinks when possible; the literal path otherwise
+ *  (a nonexistent target must still compare, and must still compare EQUAL to an
+ *  equally-nonexistent expectation rather than silently authorizing). */
+function resolveRealPath(target) {
+    try {
+        return fs.realpathSync(target);
+    }
+    catch {
+        return path.resolve(target);
+    }
+}
+/**
+ * Prove one worktree-relative path is an app-created warm-dependency link and
+ * fingerprint it. Returns null for anything that is not EXACTLY a symlink whose
+ * target resolves to the base checkout's identically-named directory — a real
+ * directory, a dereferencing copy, a dangling link, or a link into some other
+ * tree are all unauthorized and must keep preserving the worktree.
+ */
+function authenticateWarmLink(baseRepo, worktreePath, rel) {
+    const dest = path.join(worktreePath, ...rel.split('/'));
+    try {
+        if (!fs.lstatSync(dest).isSymbolicLink())
+            return null;
+        const target = path.resolve(path.dirname(dest), fs.readlinkSync(dest));
+        const expected = path.join(baseRepo, ...rel.split('/'));
+        if (resolveRealPath(target) !== resolveRealPath(expected))
+            return null;
+        // A link to something that is not a live directory proves nothing about the
+        // base checkout's dependency tree.
+        if (!isDir(target))
+            return null;
+    }
+    catch {
+        return null;
+    }
+    const fingerprint = (0, worktree_overlay_1.fingerprintOverlayCleanupPath)(dest);
+    return fingerprint ? { path: rel, ...fingerprint } : null;
+}
+/** Worktree-relative POSIX paths of every `node_modules` entry the worktree
+ *  holds at depth ≤ MAX_DEPTH. Mirrors the linker's own discovery depth, so it
+ *  can only ever see paths this module could have created. Recursion uses lstat
+ *  so a symlinked directory is never walked into. */
+function discoverWorktreeDependencyPaths(worktreePath) {
+    const found = [];
+    const walk = (rel, depth) => {
+        const abs = rel === '' ? worktreePath : path.join(worktreePath, rel);
+        let names;
+        try {
+            names = fs.readdirSync(abs);
+        }
+        catch {
+            return;
+        }
+        for (const name of names) {
+            const childRel = rel === '' ? name : `${rel}/${name}`;
+            if (name === DEPS_DIR) {
+                found.push(childRel);
+                continue;
+            }
+            if (depth >= MAX_DEPTH || name.startsWith('.'))
+                continue;
+            try {
+                if (!fs.lstatSync(path.join(abs, name)).isDirectory())
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            walk(childRel, depth + 1);
+        }
+    };
+    walk('', 0);
+    return found;
+}
+/**
+ * Live authentication of the warm-dependency links a worktree currently holds.
+ *
+ * Deriving this from the filesystem (instead of only from persisted evidence)
+ * is what heals worktrees that settled BEFORE the links carried evidence: they
+ * are stuck at `needs-review` with the link as their only "dirt", and a
+ * persisted-only fix would never reach them. The proof is identical either way
+ * — the link target anchored to a directory the app controls.
+ */
+function authenticateWarmNodeModulesLinks(baseRepo, worktreePath) {
+    const evidence = [];
+    for (const rel of discoverWorktreeDependencyPaths(worktreePath)) {
+        const entry = authenticateWarmLink(baseRepo, worktreePath, rel);
+        if (entry)
+            evidence.push(entry);
+    }
+    return evidence;
+}
 /**
  * Link the base checkout's installed `node_modules` trees into a fresh
  * worktree. Best-effort and side-effect-transparent: never throws, never
- * overwrites, returns what it created so the caller can exclude those paths
- * from commits.
+ * overwrites, and returns both what it created and what it can PROVE is a warm
+ * link (including links a previous pass created), so the caller can exclude
+ * those paths from commits and authorize them for release.
  */
 function linkNodeModulesIntoWorktree(baseRepo, worktreePath) {
-    const result = { linked: [], warnings: [] };
+    const result = { linked: [], authenticated: [], evidence: [], warnings: [] };
     if (!isWorktreeNodeModulesEnabled())
         return result;
     for (const pkgRel of discoverPackageDirs(baseRepo)) {
-        const rel = pkgRel === '' ? 'node_modules' : `${pkgRel}/node_modules`;
+        const rel = pkgRel === '' ? DEPS_DIR : `${pkgRel}/${DEPS_DIR}`;
         const src = path.join(baseRepo, ...rel.split('/'));
         if (!isDir(src))
             continue;
         const dest = path.join(worktreePath, ...rel.split('/'));
-        if (exists(dest))
-            continue;
-        try {
-            fs.mkdirSync(path.dirname(dest), { recursive: true });
-            fs.symlinkSync(src, dest, process.platform === 'win32' ? 'junction' : undefined);
-            result.linked.push(rel);
+        if (!exists(dest)) {
+            try {
+                fs.mkdirSync(path.dirname(dest), { recursive: true });
+                fs.symlinkSync(src, dest, process.platform === 'win32' ? 'junction' : undefined);
+                result.linked.push(rel);
+            }
+            catch (err) {
+                result.warnings.push(`failed to link ${rel}: ${errMsg(err)}`);
+                continue;
+            }
         }
-        catch (err) {
-            result.warnings.push(`failed to link ${rel}: ${errMsg(err)}`);
+        // Authenticate what is actually on disk NOW — a link we just made, or one a
+        // previous pass made. An entry that cannot prove itself (a real dir, an
+        // agent-made install) is deliberately left unauthorized.
+        const entry = authenticateWarmLink(baseRepo, worktreePath, rel);
+        if (entry) {
+            result.authenticated.push(rel);
+            result.evidence.push(entry);
         }
     }
     return result;