specrails-desktop 2.7.0 → 2.8.0

package/package.json

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

package/server/dist/desktop-router.js

@@ -29,13 +29,15 @@ function isCodexBetaDisabled() {
     const v = process.env.SPECRAILS_CODEX_BETA ?? process.env.SPECRAILS_HUB_CODEX_BETA;
     return v === '0';
 }
-// Gemini is opt-IN (default off): unlike codex, its stream-json schema has not
-// yet been validated against a live binary, so it stays hidden + unselectable
-// until SPECRAILS_GEMINI_BETA=1 (or 'true'). The adapter is always registered
-// (pricing/getAdapter work); only project selection is gated.
-function isGeminiBetaEnabled() {
-    const v = (process.env.SPECRAILS_GEMINI_BETA ?? '').toLowerCase();
-    return v === '1' || v === 'true';
+// Gemini is enabled by DEFAULT now that its stream-json schema and the full rails
+// pipeline (architect→developer→reviewer delegation, headless agent loading, the
+// MAX_TURNS resume + reviewer gate) are validated against the live binary
+// (0.46/0.47). Emergency rollback: SPECRAILS_GEMINI_BETA=0 forces it back to
+// "unavailable" without redeploying — parity with codex's SPECRAILS_CODEX_BETA.
+// The adapter is always registered (pricing/getAdapter work); only project
+// selection is gated.
+function isGeminiBetaDisabled() {
+    return process.env.SPECRAILS_GEMINI_BETA === '0';
 }
 // Theme allow-list. Mirror of THEME_IDS in `client/src/lib/themes.ts` —
 // kept duplicated to avoid pulling client code into the server bundle.
@@ -160,10 +162,10 @@ function createDesktopRouter(registry, broadcast) {
         const gated = { ...providers };
         if (isCodexBetaDisabled())
             gated.codex = false;
-        // Gemini is opt-in: omit it entirely (not just `false`) when the beta flag is
-        // off, so it stays fully invisible in the UI until SPECRAILS_GEMINI_BETA=1.
-        if (!isGeminiBetaEnabled())
-            delete gated.gemini;
+        // Gemini: enabled by default; forced unavailable only when
+        // SPECRAILS_GEMINI_BETA=0 (emergency rollback, parity with codex).
+        if (isGeminiBetaDisabled())
+            gated.gemini = false;
         res.json({ ...gated, tiers });
     });
     router.get('/setup-prerequisites', (req, res) => {
@@ -231,9 +233,9 @@ function createDesktopRouter(registry, broadcast) {
             });
             return;
         }
-        if (providers.includes('gemini') && !isGeminiBetaEnabled()) {
+        if (providers.includes('gemini') && isGeminiBetaDisabled()) {
             res.status(400).json({
-                error: 'Gemini provider is in beta and disabled by default. Set SPECRAILS_GEMINI_BETA=1 to enable.',
+                error: 'Gemini provider is currently disabled (SPECRAILS_GEMINI_BETA=0). Unset or set to 1 to enable.',
             });
             return;
         }

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

@@ -29,6 +29,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports._GEMINI_MIN_VERSION = exports.geminiAdapter = void 0;
 exports._compareSemver = compareSemver;
 const child_process_1 = require("child_process");
+const gemini_agent_ack_1 = require("./gemini-agent-ack");
 const WHICH_CMD = process.platform === 'win32' ? 'where' : 'which';
 // Floor where `--output-format stream-json` + headless `--resume` are available.
 const GEMINI_MIN_VERSION = '0.11.0';
@@ -231,4 +232,7 @@ exports.geminiAdapter = {
     extractResult: extractGeminiResult,
     baselineAgents: () => ['sr-architect', 'sr-developer', 'sr-reviewer'],
     detectInstalled: detectGeminiInstalled,
+    // Pre-acknowledge the project's custom subagents so they load in headless
+    // `gemini -p` rail spawns (else invoke_agent reports "Subagent not found").
+    prepareHeadlessSpawn: gemini_agent_ack_1.acknowledgeGeminiProjectAgents,
 };

package/server/dist/providers/gemini-agent-ack.js

@@ -0,0 +1,65 @@
+"use strict";
+// Gemini headless subagent pre-acknowledgment.
+//
+// gemini 0.46+ DISCOVERS `<project>/.gemini/agents/*.md` but only ENABLES a
+// project's custom subagents after an interactive "New Agents Discovered →
+// Acknowledge and Enable" prompt. That prompt never fires in headless
+// (`gemini -p`) spawns — which is how the desktop runs every rail — so
+// `invoke_agent sr-architect` returns "Subagent not found" and the implement
+// orchestrator silently falls back to a generic agent (the specialised
+// architect/developer/reviewer personas never run in isolation).
+//
+// specrails-core writes the acknowledgment file at install time; this is the
+// defence-in-depth copy the desktop runs right before a gemini rail spawn, so a
+// project installed with an older core (or whose agents changed since install)
+// is still trusted headless. The file gemini reads is
+// `~/.gemini/acknowledgments/agents.json`, shaped
+//   { [projectRoot]: { [agentName]: <sha256-hex of the agent .md file> } }
+// where the hash is sha256 of the FULL agent markdown file (verified empirically
+// against gemini 0.47). Entries are MERGED so other projects (and other agents)
+// survive. Best-effort — callers swallow any error; a failure only means the
+// agents need the one-time interactive acknowledge.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.acknowledgeGeminiProjectAgents = acknowledgeGeminiProjectAgents;
+const crypto_1 = require("crypto");
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+function ackFilePath() {
+    return (0, path_1.join)((0, os_1.homedir)(), '.gemini', 'acknowledgments', 'agents.json');
+}
+/**
+ * Pre-acknowledge every `<projectPath>/.gemini/agents/*.md` so gemini loads them
+ * in headless mode. No-op when the project has no `.gemini/agents` dir or no
+ * agent files. The `projectPath` is the key gemini uses (the spawn cwd / repo
+ * root), matching what `specrails-core` writes at install.
+ */
+function acknowledgeGeminiProjectAgents(projectPath) {
+    const agentsDir = (0, path_1.join)(projectPath, '.gemini', 'agents');
+    if (!(0, fs_1.existsSync)(agentsDir))
+        return;
+    const agentFiles = (0, fs_1.readdirSync)(agentsDir).filter((f) => f.endsWith('.md') && !f.startsWith('_'));
+    if (agentFiles.length === 0)
+        return;
+    const ackPath = ackFilePath();
+    let store = {};
+    if ((0, fs_1.existsSync)(ackPath)) {
+        try {
+            const parsed = JSON.parse((0, fs_1.readFileSync)(ackPath, 'utf8'));
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                store = parsed;
+            }
+        }
+        catch {
+            // Corrupt/unreadable file — start fresh rather than crash the spawn.
+        }
+    }
+    const projectEntry = { ...(store[projectPath] ?? {}) };
+    for (const file of agentFiles) {
+        const content = (0, fs_1.readFileSync)((0, path_1.join)(agentsDir, file), 'utf8');
+        projectEntry[file.slice(0, -3)] = (0, crypto_1.createHash)('sha256').update(content).digest('hex');
+    }
+    store[projectPath] = projectEntry;
+    (0, fs_1.mkdirSync)((0, path_1.join)((0, os_1.homedir)(), '.gemini', 'acknowledgments'), { recursive: true });
+    (0, fs_1.writeFileSync)(ackPath, `${JSON.stringify(store, null, 2)}\n`);
+}

package/server/dist/queue-manager.js

@@ -1000,6 +1000,19 @@ class QueueManager {
                 };
             }
         }
+        // Provider-specific filesystem prep before a headless rail spawn. Gemini
+        // uses this to pre-acknowledge the project's custom subagents so they load
+        // in `gemini -p` mode (else invoke_agent reports "Subagent not found" and the
+        // orchestrator silently falls back to a generic agent). No-op for claude/codex.
+        if (this._cwd) {
+            try {
+                adapter.prepareHeadlessSpawn?.(this._cwd);
+            }
+            catch (err) {
+                /* c8 ignore next -- best-effort prep; a failure is non-fatal */
+                console.warn(`[queue-manager] headless-spawn prep failed: ${err.message}`);
+            }
+        }
         // ─── Interactive ultracode branch ──────────────────────────────────────
         // When the launch requested interactive mode AND the command is ultracode
         // AND the adapter supports persistent stdin (claude), hand off to a resident

package/server/dist/util/stream-display.js

@@ -9,7 +9,8 @@ exports.extractDisplayText = extractDisplayText;
 /**
  * Map a parsed provider stream-json frame to the single display line the Job
  * Detail log shows (or null when the frame carries no user-facing text).
- * Handles both Claude `--output-format stream-json` and Codex `exec --json`.
+ * Handles Claude `--output-format stream-json`, Codex `exec --json`, and Gemini
+ * `--output-format stream-json` frame shapes.
  */
 function extractDisplayText(event) {
     const type = event.type;
@@ -22,10 +23,24 @@ function extractDisplayText(event) {
         return texts.join('') || null;
     }
     if (type === 'tool_use') {
-        const name = event.name;
-        const input = JSON.stringify(event.input ?? {});
+        // Claude emits `name`/`input`; Gemini stream-json uses `tool_name`/`parameters`.
+        // Tolerating both keeps a single tool_use branch across providers — without
+        // this fallback every Gemini tool call renders as `[tool: undefined] {}`.
+        const e = event;
+        const name = e.name ?? e.tool_name ?? '<unnamed>';
+        const input = JSON.stringify(e.input ?? e.parameters ?? {});
         return `[tool: ${name}] ${input.slice(0, 120)}`;
     }
+    if (type === 'message') {
+        // Gemini stream-json streams assistant text as `message` delta frames whose
+        // `content` is a plain string; the `role:"user"` echo carries no display
+        // value. Without this branch the Job Detail log drops all Gemini narration.
+        const e = event;
+        if (e.role !== 'assistant')
+            return null;
+        const text = e.content ?? '';
+        return text.length > 0 ? text : null;
+    }
     if (type === 'tool_result' || type === 'system_prompt' || type === 'user' || type === 'system' || type === 'result') {
         return null;
     }