specrails-desktop 2.11.8 → 2.11.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "specrails-desktop",
-  "version": "2.11.8",
+  "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/path-resolver.js

@@ -157,6 +157,16 @@ function windowsGlobalBinDirs() {
         dirs.push(path_1.default.join(userProfile, '.local', 'bin'));
         dirs.push(path_1.default.join(userProfile, 'scoop', 'shims'));
     }
+    // Windows system dirs. A GUI-launched / pkg-stripped sidecar can inherit a PATH
+    // missing %SystemRoot%\System32 — which holds `taskkill`/`where`, and \Wbem
+    // holds `wmic`. Without them, cmd.exe-mediated tools fail: `tree-kill`'s
+    // `taskkill` silently no-ops (a cancelled rail keeps running). Existence-gated
+    // by the callers; harmless when already present (the common case).
+    const systemRoot = process.env.SystemRoot || process.env.windir;
+    if (systemRoot) {
+        dirs.push(path_1.default.join(systemRoot, 'System32'));
+        dirs.push(path_1.default.join(systemRoot, 'System32', 'Wbem'));
+    }
     return dirs;
 }
 /**

package/server/dist/project-router-jobs.js

@@ -115,6 +115,11 @@ function registerJobsRoutes(deps) {
                 res.json({ ok: true, status: 'deleted' });
             }
             else {
+                // Surface the real error (name/message/stack) so an unexpected cancel
+                // failure — e.g. a Windows kill throw — is identifiable instead of being
+                // masked as a bare "Internal server error".
+                const e = err;
+                console.error(`[jobs] cancel ${req.params.id} failed: ${e?.name}: ${e?.message}\n${e?.stack ?? ''}`);
                 res.status(500).json({ error: 'Internal server error' });
             }
         }

package/server/dist/queue-manager.js

@@ -10,7 +10,7 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const readline_1 = require("readline");
 const ids_1 = require("./ids");
-const tree_kill_1 = __importDefault(require("tree-kill"));
+const win_spawn_1 = require("./util/win-spawn");
 const types_1 = require("./types");
 const command_resolver_1 = require("./command-resolver");
 const cli_prompt_1 = require("./util/cli-prompt");
@@ -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");
@@ -283,12 +284,12 @@ class QueueManager {
         if (proc && proc.pid) {
             const pid = proc.pid;
             try {
-                (0, tree_kill_1.default)(pid, 'SIGTERM');
+                (0, win_spawn_1.treeKillSafe)(pid, 'SIGTERM', () => { });
             }
             catch { /* best-effort */ }
             const grace = setTimeout(() => {
                 try {
-                    (0, tree_kill_1.default)(pid, 'SIGKILL', () => { });
+                    (0, win_spawn_1.treeKillSafe)(pid, 'SIGKILL', () => { });
                 }
                 catch { /* best-effort */ }
             }, 5000);
@@ -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;
@@ -993,6 +1007,33 @@ class QueueManager {
         // Build supplementary context (output chaining + headless mode) that goes
         // into --append-system-prompt, keeping the user prompt clean.
         let systemAppend = '';
+        // Repository orientation (relocated projects only). The rail spawns from the
+        // WORKSPACE cwd, which holds only `.specrails/` config — NOT the source code.
+        // The repo is reachable via `--add-dir <repoDir>` (injected below) and the
+        // `./project` link. The framework templates point at `${SPECRAILS_REPO_DIR:-.}`,
+        // but the agent's Read/Grep/Glob/Edit tools do NOT expand that shell-var form
+        // (and PowerShell/cmd.exe don't expand POSIX `${VAR:-default}` either) — so on
+        // Windows the agent reads a bogus literal path, falls back to the empty
+        // workspace cwd, finds only framework files, and hallucinates a wrong/"global"
+        // project. Tell it the concrete absolute repo path explicitly. Mirrors the
+        // Explore-cwd orientation. Legacy (non-relocated) ⇒ cwd IS the repo ⇒ skipped
+        // (byte-identical). The `\${` keeps the shell-var form literal in this string.
+        if (execution.relocated && execution.repoDir) {
+            systemAppend +=
+                `REPOSITORY LOCATION — READ THIS FIRST:\n` +
+                    `This pipeline runs from a workspace directory that contains ONLY specrails ` +
+                    `configuration (.specrails/, agent definitions) — NOT your project's source code. ` +
+                    `Your project's source repository is at this ABSOLUTE path:\n` +
+                    `  ${execution.repoDir}\n` +
+                    `It is also exposed to your tools as an additional working directory (via --add-dir) ` +
+                    `and mounted in this cwd as ./project. Use the absolute repo path above (or ./project) ` +
+                    `for ALL source reads, edits, greps and globs. Your Read/Grep/Glob/Edit tools do NOT ` +
+                    `expand shell variables — NEVER pass a literal "\${SPECRAILS_REPO_DIR:-.}" or ` +
+                    `"\${SPECRAILS_REPO_DIR}" as a path; substitute the absolute path above instead. ` +
+                    `The spec/ticket store (.specrails/local-tickets.json) lives in THIS workspace cwd. ` +
+                    `Do NOT look for source files under this cwd — they exist only under the repository ` +
+                    `path above.\n\n`;
+        }
         // Output chaining: inject previous step's output as context for dependent jobs
         if (job.dependsOnJobId) {
             const parentJob = this._jobs.get(job.dependsOnJobId);
@@ -1788,10 +1829,22 @@ class QueueManager {
             clearTimeout(this._killTimer);
             this._killTimer = null;
         }
-        (0, tree_kill_1.default)(this._activeProcess.pid, 'SIGTERM');
         const pid = this._activeProcess.pid;
+        // treeKillSafe never throws synchronously, but wrap defensively so a kill
+        // failure can NEVER propagate into the cancel HTTP route as a 500. On Windows
+        // it invokes an absolute taskkill (PATH-independent) so the tree is actually
+        // killed; the callback surfaces any failure instead of swallowing it.
+        try {
+            (0, win_spawn_1.treeKillSafe)(pid, 'SIGTERM', (err) => {
+                if (err)
+                    console.error(`[kill] SIGTERM tree-kill failed for pid ${pid}: ${err.message}`);
+            });
+        }
+        catch (err) {
+            console.error(`[kill] SIGTERM tree-kill threw for pid ${pid}: ${err.message}`);
+        }
         this._killTimer = setTimeout(() => {
-            (0, tree_kill_1.default)(pid, 'SIGKILL', (err) => {
+            (0, win_spawn_1.treeKillSafe)(pid, 'SIGKILL', (err) => {
                 if (err) {
                     // SIGKILL failed — force cleanup so queue is not permanently blocked.
                     console.error(`[kill] SIGKILL failed for pid ${pid}: ${err.message}`);

package/server/dist/util/win-spawn.js

@@ -24,6 +24,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.treeKillSafe = treeKillSafe;
 exports.spawnCli = spawnCli;
 exports.windowsSpawnEnv = windowsSpawnEnv;
 exports.stripWindowsVerbatimPrefix = stripWindowsVerbatimPrefix;
@@ -32,6 +33,39 @@ exports.__resetWindowsBinaryResolveCacheForTest = __resetWindowsBinaryResolveCac
 const child_process_1 = require("child_process");
 const path_1 = __importDefault(require("path"));
 const cross_spawn_1 = __importDefault(require("cross-spawn"));
+const tree_kill_1 = __importDefault(require("tree-kill"));
+/**
+ * Kill a process tree, robustly on Windows. `tree-kill` shells out to
+ * `exec('taskkill /pid … /T /F')` through cmd.exe, which resolves `taskkill`
+ * against the spawn env's PATH — but `taskkill.exe` lives in
+ * `%SystemRoot%\System32`, which a GUI-launched / pkg-stripped sidecar's PATH can
+ * lack, so the kill silently no-ops (the rail keeps running) and, with no
+ * callback, the failure is swallowed. Here we instead invoke the ABSOLUTE
+ * `taskkill.exe` with a SystemRoot-backfilled env (`windowsSpawnEnv`), so the
+ * kill never depends on PATH. POSIX delegates to `tree-kill` unchanged
+ * (byte-identical). Errors are always surfaced via `callback`.
+ */
+function treeKillSafe(pid, signal, callback) {
+    const done = (err) => { if (callback)
+        callback(err); };
+    if (process.platform !== 'win32') {
+        (0, tree_kill_1.default)(pid, signal, (err) => done(err ?? undefined));
+        return;
+    }
+    /* c8 ignore start -- Windows-only branch; coverage runs on Linux/macOS */
+    try {
+        const env = windowsSpawnEnv();
+        const systemRoot = (env.SystemRoot || env.windir || 'C:\\Windows').replace(/[\\/]$/, '');
+        const taskkill = path_1.default.join(systemRoot, 'System32', 'taskkill.exe');
+        // /T = whole tree, /F = force. taskkill has no SIGTERM/SIGKILL distinction;
+        // `tree-kill` already always force-kills on win32, so behaviour is unchanged.
+        (0, child_process_1.execFile)(taskkill, ['/pid', String(pid), '/T', '/F'], { env }, (err) => done(err ?? undefined));
+    }
+    catch (err) {
+        done(err);
+    }
+    /* c8 ignore stop */
+}
 function spawnCli(binary, args, options = {}) {
     /* c8 ignore next 8 -- Windows-only branch; coverage runs on Linux/macOS */
     if (process.platform === 'win32') {

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