specrails-desktop 2.11.9 → 2.11.10

package/package.json

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

package/server/dist/contract-refine-runner.js

@@ -94,22 +94,32 @@ function prepareContractRefineSpawn(deps, conversation) {
             /* default false */
         }
     }
-    // Relocate-artifacts: when mcp is on, the spawn cwd is the project's spec root,
-    // which becomes the workspace when relocated (else project.path). When mcp is
-    // off the explore-cwd is used as before. Env carries SPECRAILS_REPO_DIR for the
-    // relocated case so source/openspec I/O re-points into the repo.
+    // The refine `--resume`s the Explore conversation's session, so it MUST spawn
+    // from the SAME cwd the Explore turn used — otherwise claude looks in a
+    // different per-cwd session store and fails with "No conversation found with
+    // session ID …" (the Desktop-tier bug). chat-manager `_resolveSpawnCwd` for an
+    // Explore turn uses:
+    //   - mcp ON  → `project.path` (NOT the relocated workspace),
+    //   - mcp OFF → the app-managed explore-cwd.
+    // We mirror that EXACTLY here. The refine uses no file tools (`--disallowedTools
+    // Read,Grep,Glob,Bash`) and its prompt rides on `--system-prompt`, so it needs
+    // neither the workspace's `.mcp.json` nor its `.claude/commands`. Env still
+    // carries SPECRAILS_REPO_DIR when relocated (harmless; no tools consume it).
     const exec = (0, workspace_resolution_1.resolveProjectExecution)({ slug: deps.projectSlug, path: deps.projectPath });
-    let cwd = exec.cwd;
     let env = exec.relocated ? { ...process.env, ...exec.env } : undefined;
-    if (!mcpEnabled) {
+    let cwd;
+    if (mcpEnabled) {
+        // Match the Explore mcp-on spawn cwd (`this._cwd` = project.path), even when
+        // relocated (where exec.cwd would be the workspace ≠ project.path).
+        cwd = deps.projectPath;
+    }
+    else {
         try {
             cwd = (0, explore_cwd_manager_1.ensureExploreCwd)({
                 slug: deps.projectSlug,
                 projectPath: deps.projectPath,
                 projectName: deps.projectName,
             });
-            // explore-cwd reaches the repo via its own `./project` link; keep the
-            // relocation env so SPECRAILS_REPO_DIR is still exported when relocated.
         }
         catch {
             cwd = exec.cwd;

package/server/dist/queue-manager.js

@@ -28,6 +28,7 @@ const interactive_job_session_1 = require("./interactive-job-session");
 const attachment_manager_1 = require("./attachment-manager");
 const ticket_store_1 = require("./ticket-store");
 const binary_probe_1 = require("./binary-probe");
+const workspace_manager_1 = require("./workspace-manager");
 const workspace_resolution_1 = require("./workspace-resolution");
 const framework_manager_1 = require("./framework-manager");
 const openspec_shim_1 = require("./openspec-shim");
@@ -976,6 +977,19 @@ class QueueManager {
         const execution = this._resolveExecution();
         this._jobExecution.set(jobId, execution);
         const spawnCwd = execution.cwd;
+        // Windows repair: a relocated workspace whose `.claude/agents` was left empty
+        // by the broken `current`-junction read during assemble has no sr-* agents,
+        // so the implement pipeline can't delegate and runs inline. Self-heal here
+        // (per rail spawn) by copying the agents from the real version dir. NO-OP on
+        // POSIX (assemble's per-file symlinks already populate them).
+        if (execution.relocated) {
+            try {
+                (0, workspace_manager_1.ensureFrameworkAgents)(execution.cwd, adapter.projectDirName);
+            }
+            catch {
+                /* best-effort — never block a rail spawn on the repair */
+            }
+        }
         job.status = 'running';
         job.startedAt = new Date().toISOString();
         job.queuePosition = null;

package/server/dist/workspace-manager.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureFrameworkAgents = ensureFrameworkAgents;
 exports.workspacePathFor = workspacePathFor;
 exports.ensureWorkspace = ensureWorkspace;
 exports.assembleWorkspaceFramework = assembleWorkspaceFramework;
@@ -12,6 +13,85 @@ const path_1 = __importDefault(require("path"));
 const framework_manager_1 = require("./framework-manager");
 const framework_migration_1 = require("./framework-migration");
 const artifact_registry_1 = require("./artifact-registry");
+/** Highest-first semver-ish sort for framework version dir names. */
+function compareFrameworkVersionDesc(a, b) {
+    const pa = a.split('.').map((n) => parseInt(n, 10));
+    const pb = b.split('.').map((n) => parseInt(n, 10));
+    for (let i = 0; i < 3; i++) {
+        const x = pa[i] ?? 0;
+        const y = pb[i] ?? 0;
+        if (x !== y)
+            return y - x;
+    }
+    return 0;
+}
+/**
+ * Windows repair: ensure the workspace's `<providerDir>/agents` holds the
+ * framework's `sr-*` agent definitions, copied from the REAL versioned framework
+ * dir (`~/.specrails/framework/<version>/<providerDir>/agents`).
+ *
+ * Why: on Windows the `framework/current` JUNCTION can be untraversable by Node's
+ * `fs` ("UNKNOWN: scandir" / "untrusted mount point"); the bundled core's
+ * `assemble` sources the agents THROUGH `current`, so `linkAgentFiles` reads
+ * nothing and the workspace ends up with NO `sr-*` agents — the implement
+ * pipeline then has no sub-agents to delegate to (architect/developer/reviewer)
+ * and silently runs everything inline. The versioned dir is a real, traversable
+ * directory, so we read it directly. (The proper fix lives in core's `assemble`;
+ * this repairs already-broken installs without waiting for a core republish, and
+ * mirrors exactly what the fixed core does on Windows — copy from the version
+ * dir.) `assemble` never re-runs on a rail spawn, so a workspace broken at setup
+ * stays broken; this runs per rail spawn to self-heal it.
+ *
+ * NO-OP on POSIX (per-file symlinks already populate the workspace correctly;
+ * byte-identical). Additive (never touches user `custom-*.md`) + idempotent.
+ * Returns the number of agents copied.
+ */
+function ensureFrameworkAgents(workspaceDir, providerDir, home) {
+    if (process.platform !== 'win32')
+        return 0;
+    const root = (0, framework_manager_1.frameworkRoot)(home);
+    // Resolve the framework version by listing REAL version dirs — NOT via the
+    // `current` junction (which is the very thing that may be untraversable here).
+    let version;
+    try {
+        version = fs_1.default
+            .readdirSync(root)
+            .filter((n) => /^\d+\.\d+\.\d+$/.test(n))
+            .sort(compareFrameworkVersionDesc)[0];
+    }
+    catch {
+        return 0;
+    }
+    if (!version)
+        return 0;
+    const src = path_1.default.join(root, version, providerDir, 'agents');
+    let entries;
+    try {
+        entries = fs_1.default.readdirSync(src);
+    }
+    catch {
+        return 0; // framework agents not materialized for this provider
+    }
+    const dest = path_1.default.join(workspaceDir, providerDir, 'agents');
+    let copied = 0;
+    for (const name of entries) {
+        // Framework agents only; never clobber a user/plugin `custom-*.md`.
+        if (!name.endsWith('.md') || name.startsWith('custom-'))
+            continue;
+        const destFile = path_1.default.join(dest, name);
+        if (fs_1.default.existsSync(destFile))
+            continue;
+        try {
+            fs_1.default.mkdirSync(dest, { recursive: true });
+            fs_1.default.copyFileSync(path_1.default.join(src, name), destFile);
+            copied += 1;
+        }
+        catch {
+            /* best-effort per file — one failure must never abort the rail spawn */
+        }
+    }
+    return copied;
+}
 /**
  * WorkspaceManager — a reusable materializer for the per-project workspace dir
  * under `~/.specrails/projects/<slug>/workspace`. This is the relocation target