specrails-desktop 2.23.0 → 2.23.1

package/package.json

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

package/server/dist/agent-operator-prompt.js

@@ -326,15 +326,24 @@ summary later.
   advances from "building" to the PR question on its own), and the app's rail
   header / Job Detail page stream every event. Tell the user that, and that
   they can ask you for a status check any time (\`specrails_jobs(get)\`).
-- **After a rail settles, the DECISION belongs to the user, in the app's UI**
-  (the PR card in this chat and the rail header show the same buttons): Create
-  PR → draft on GitHub; Publish; Discard. There is NO "Ship/Revert" — never
-  invent UI. When the repo has NO GitHub remote (or push fails), Create PR
-  degrades to a local-only delivery: the card then offers **Integrate locally**
-  (merge the delivered branches into the integration branch in the user's
-  checkout — requires that branch checked out + a clean tree) as the way to
-  ACCEPT the work, alongside retry and Discard. Explain exactly that when the
-  user asks "where is the PR?" on a remote-less repo.
+- **A PR-decision card only exists when the launch isolated in a git worktree.**
+  A launch response with an \`isolationUnavailable\` field means the run fell back
+  to the shared working tree — there is NO card (not in this chat, not on the
+  rail header) and NO branch. NEVER promise a card in that case; instead tell the
+  user the run writes changes DIRECTLY into their files, say why (\`no-git\` = the
+  folder is not a git repo; \`no-commits\` = git repo with no initial commit;
+  \`error\` = isolation failed, relay the detail), and — for no-git/no-commits —
+  that \`git init\` + one commit (no GitHub remote needed) unlocks the PR flow.
+  When isolation IS available (no such field), the card WILL appear on settle.
+- **After an ISOLATED rail settles, the DECISION belongs to the user, in the
+  app's UI** (the PR card in this chat and the rail header show the same
+  buttons): Create PR → draft on GitHub; Publish; Discard. There is NO
+  "Ship/Revert" — never invent UI. When the repo has NO GitHub remote (or push
+  fails), Create PR degrades to a local-only delivery: the card then offers
+  **Integrate locally** (merge the delivered branches into the integration
+  branch in the user's checkout — requires that branch checked out + a clean
+  tree) as the way to ACCEPT the work, alongside retry and Discard. Explain
+  exactly that when the user asks "where is the PR?" on a remote-less repo.
 - \`specrails_watch\` on a launched rail/job is RESERVED for when the user
   explicitly asks you to wait for completion ("wait until it finishes"). Even
   then prefer a bounded \`untilMs\` and report status back when it elapses —

package/server/dist/loop-executors.js

@@ -133,6 +133,7 @@ function createLoopExecutors(opts = {}) {
             if (repoDir) {
                 try {
                     (0, workspace_manager_1.ensureFrameworkAgents)(cwd, adapter.projectDirName);
+                    (0, workspace_manager_1.ensureFrameworkCommandSubtrees)(cwd, adapter.projectDirName);
                 }
                 catch { /* best-effort */ }
             }
@@ -243,6 +244,7 @@ function createLoopExecutors(opts = {}) {
             if (repoDir) {
                 try {
                     (0, workspace_manager_1.ensureFrameworkAgents)(cwd, adapter.projectDirName);
+                    (0, workspace_manager_1.ensureFrameworkCommandSubtrees)(cwd, adapter.projectDirName);
                 }
                 catch { /* best-effort */ }
             }

package/server/dist/mcp/tools/rails.js

@@ -208,10 +208,33 @@ function railsTools() {
                             body.reasoning_effort = defaults.reasoningEffort;
                         }
                         const r = await (0, types_1.apiCall)(ctx, 'POST', `${base}/${railIndex}/launch`, body);
+                        const railLabel = `Rail ${railIndex + 1}`;
+                        // Isolation status governs whether a PR-decision card EXISTS. When
+                        // the router reports `isolationUnavailable`, the run fell back to the
+                        // shared working tree: NO git worktree, NO PR delivery row, and so
+                        // NO implementation/PR card will EVER appear (not in this chat, not
+                        // in the rail header). The agent MUST NOT promise one — it must tell
+                        // the user the run writes changes DIRECTLY to their files and why.
+                        const isoReason = typeof r.isolationUnavailable === 'string' ? r.isolationUnavailable : null;
+                        if (isoReason) {
+                            const why = isoReason === 'no-git'
+                                ? 'the project folder is NOT a git repository'
+                                : isoReason === 'no-commits'
+                                    ? 'the git repository has NO commits yet (an unborn HEAD cannot be branched)'
+                                    : `worktree isolation failed${typeof r.isolationUnavailableDetail === 'string' ? `: ${r.isolationUnavailableDetail}` : ''}`;
+                            const fix = isoReason === 'error'
+                                ? 'This is unexpected — report the detail to the user.'
+                                : 'To get the PR flow, the user should `git init` the folder and make at least one commit (a GitHub remote is NOT required — the review flow then offers "Integrate locally" to accept without GitHub), then relaunch.';
+                            return {
+                                ...r,
+                                railLabel,
+                                hint: `Launch accepted (202) on ${railLabel}, but WORKTREE ISOLATION IS UNAVAILABLE because ${why}. The run proceeds on the SHARED working tree and writes changes DIRECTLY into the user's files — there is NO PR-decision/implementation card and NO branch. Do NOT tell the user to look for a PR card; tell them the run writes to their files in place, and explain why. ${fix} When it finishes, the spec parks at on_review — the user accepts it by moving it to Done on the board (the changes are already in their files) or reverts the spec's status (which does NOT undo the file changes).`,
+                            };
+                        }
                         return {
                             ...r,
-                            railLabel: `Rail ${railIndex + 1}`,
-                            hint: `Launch accepted (202) on railIndex ${railIndex} — tell the user it runs on "Rail ${railIndex + 1}" (UI labels are 1-based). Use specrails_watch with the returned jobId/jobIds (or loopRunIds for loop mode) to await completion. Live output streams over the job WS. Rails run for minutes; pass untilMs up to 600000 and re-watch on timeout.`,
+                            railLabel,
+                            hint: `Launch accepted (202) on ${railLabel} (isolated worktree, PR flow active) — tell the user it runs on "${railLabel}" (UI labels are 1-based) and that the PR-decision card will appear here and on the rail header when it settles. Use specrails_watch with the returned loopRunIds to await completion only if asked. Rails run for minutes; pass untilMs up to 600000 and re-watch on timeout.`,
                         };
                     }
                     case 'launch_all': {

package/server/dist/queue-manager.js

@@ -1427,6 +1427,10 @@ class QueueManager {
         if (execution.relocated) {
             try {
                 (0, workspace_manager_1.ensureFrameworkAgents)(execution.cwd, adapter.projectDirName);
+                // AND the dir-linked subtrees (commands/skills/rules): a broken Windows
+                // `current` junction leaves the workspace with no `/specrails:*` commands
+                // → the CLI reports "Unknown command: /specrails:implement".
+                (0, workspace_manager_1.ensureFrameworkCommandSubtrees)(execution.cwd, adapter.projectDirName);
             }
             catch {
                 /* best-effort — never block a rail spawn on the repair */

package/server/dist/workspace-manager.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensureFrameworkAgents = ensureFrameworkAgents;
+exports.ensureFrameworkCommandSubtrees = ensureFrameworkCommandSubtrees;
 exports.workspacePathFor = workspacePathFor;
 exports.ensureWorkspace = ensureWorkspace;
 exports.assembleWorkspaceFramework = assembleWorkspaceFramework;
@@ -47,22 +48,25 @@ function compareFrameworkVersionDesc(a, b) {
  * 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;
+/** Newest REAL framework version dir under the root — resolved by LISTING (not
+ *  via the `current` junction, which is the very thing that may be untraversable
+ *  on Windows). Null when the framework isn't materialized. */
+function newestFrameworkVersion(root) {
     try {
-        version = fs_1.default
+        return fs_1.default
             .readdirSync(root)
             .filter((n) => /^\d+\.\d+\.\d+$/.test(n))
-            .sort(compareFrameworkVersionDesc)[0];
+            .sort(compareFrameworkVersionDesc)[0] ?? null;
     }
     catch {
-        return 0;
+        return null;
     }
+}
+function ensureFrameworkAgents(workspaceDir, providerDir, home) {
+    if (process.platform !== 'win32')
+        return 0;
+    const root = (0, framework_manager_1.frameworkRoot)(home);
+    const version = newestFrameworkVersion(root);
     if (!version)
         return 0;
     const src = path_1.default.join(root, version, providerDir, 'agents');
@@ -93,6 +97,93 @@ function ensureFrameworkAgents(workspaceDir, providerDir, home) {
     }
     return copied;
 }
+/** The framework subtrees `assemble` installs as a single DIR-symlink into
+ *  `current/<provider>/` (unlike agents, which are per-file). `/specrails:*`
+ *  and `/opsx:*` slash commands live under `commands/`. */
+const DIR_LINKED_SUBTREES = ['commands', 'skills', 'rules'];
+/**
+ * Windows repair for the DIR-symlinked framework subtrees (`commands`, `skills`,
+ * `rules`) — the sibling of `ensureFrameworkAgents` for the whole-directory links.
+ *
+ * Why a SEPARATE repair: agents are linked per-file, so a broken `current`
+ * junction leaves an EMPTY-but-real `agents/` dir that `ensureFrameworkAgents`
+ * refills file-by-file. `commands`/`skills`/`rules` are instead a single
+ * dir-symlink INTO `current/<provider>/<subtree>`; when the `current` junction is
+ * untraversable by the sidecar (the documented Windows failure), that link is
+ * unreadable and the workspace has NO `/specrails:*` commands at all — the claude
+ * CLI then reports `Unknown command: /specrails:implement`. This replaces an
+ * unreadable/missing link with a REAL recursively-copied directory read straight
+ * from the versioned framework dir (never through `current`).
+ *
+ * SAFETY: only heals when the dest is missing OR unreadable OR empty — a dest
+ * that lists content is a working link/dir and is left untouched, so a working
+ * symlink's real target is NEVER deleted through. NO-OP on POSIX (per-provider
+ * symlinks resolve normally). Best-effort + idempotent. Returns the count healed.
+ */
+function ensureFrameworkCommandSubtrees(workspaceDir, providerDir, home) {
+    if (process.platform !== 'win32')
+        return 0;
+    const root = (0, framework_manager_1.frameworkRoot)(home);
+    const version = newestFrameworkVersion(root);
+    if (!version)
+        return 0;
+    let healed = 0;
+    for (const subtree of DIR_LINKED_SUBTREES) {
+        const src = path_1.default.join(root, version, providerDir, subtree);
+        // The versioned source must be a real, readable, non-empty dir to heal from.
+        let srcEntries;
+        try {
+            srcEntries = fs_1.default.readdirSync(src);
+        }
+        catch {
+            continue; // this provider/version ships no such subtree
+        }
+        if (srcEntries.length === 0)
+            continue;
+        const dest = path_1.default.join(workspaceDir, providerDir, subtree);
+        // A dest that lists entries is a working link/dir → leave it (never risk
+        // deleting through a live symlink). Heal only when unreadable / empty.
+        try {
+            if (fs_1.default.readdirSync(dest).length > 0)
+                continue;
+        }
+        catch {
+            /* unreadable (broken/untraversable link, or missing) → heal below */
+        }
+        // Remove the broken link / empty dir. We only reach here when there is no
+        // traversable content, so no real framework files can be destroyed. Layered
+        // removal because a Windows dir-junction resists unlink/rmdir differently.
+        try {
+            const st = fs_1.default.lstatSync(dest);
+            if (st.isSymbolicLink()) {
+                fs_1.default.unlinkSync(dest);
+            }
+            else {
+                fs_1.default.rmSync(dest, { recursive: true, force: true });
+            }
+        }
+        catch {
+            try {
+                fs_1.default.rmdirSync(dest);
+            }
+            catch {
+                try {
+                    fs_1.default.rmSync(dest, { recursive: true, force: true });
+                }
+                catch { /* dest may be absent — fine */ }
+            }
+        }
+        try {
+            fs_1.default.mkdirSync(path_1.default.dirname(dest), { recursive: true });
+            fs_1.default.cpSync(src, dest, { recursive: true });
+            healed += 1;
+        }
+        catch {
+            /* best-effort per subtree — a copy failure must never abort the spawn */
+        }
+    }
+    return healed;
+}
 /**
  * WorkspaceManager — a reusable materializer for the per-project workspace dir
  * under `~/.specrails/projects/<slug>/workspace`. This is the relocation target