specrails-desktop 2.6.0 → 2.8.0

package/server/dist/core-package.js

@@ -8,7 +8,12 @@ exports.CORE_PACKAGE_SPEC = void 0;
  * minute it is published — adopting a new major is a deliberate one-line
  * bump here, shipped through the app's own release pipeline.
  *
+ * Floor bumped to 4.8.0 — the version that ships the Gemini provider target
+ * (`.gemini/` commands + agents). It also changes the `npx` package-spec string,
+ * which invalidates any stale `_npx` exec cache that npx would otherwise reuse
+ * for the old `^4.6.0` range (so users actually resolve the newer core).
+ *
  * `SPECRAILS_CORE_BIN` remains the escape hatch for local/linked builds
  * (see getCoreCommand in setup-manager.ts).
  */
-exports.CORE_PACKAGE_SPEC = 'specrails-core@^4.6.0';
+exports.CORE_PACKAGE_SPEC = 'specrails-core@^4.8.0';

package/server/dist/desktop-router.js

@@ -29,6 +29,16 @@ function isCodexBetaDisabled() {
     const v = process.env.SPECRAILS_CODEX_BETA ?? process.env.SPECRAILS_HUB_CODEX_BETA;
     return v === '0';
 }
+// 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.
 const THEME_ID_ALLOWLIST = new Set(['dracula', 'aurora-light', 'obsidian-dark', 'matrix', 'specrails']);
@@ -144,14 +154,19 @@ function createDesktopRouter(registry, broadcast) {
         const providers = (0, core_compat_1.detectAvailableCLIs)();
         // tiers: quick install is always available (app-driven config); full requires an AI CLI
         const tiers = ['quick'];
-        if (providers.claude || providers.codex)
+        if (Object.values(providers).some(Boolean))
             tiers.push('full');
-        const codexBetaOff = isCodexBetaDisabled();
-        res.json({
-            claude: providers.claude,
-            codex: codexBetaOff ? false : providers.codex,
-            tiers,
-        });
+        // Return the full detected map (registry-driven) so a newly-registered
+        // provider surfaces here with no edit. Apply per-provider beta gates: codex
+        // is forced unavailable when SPECRAILS_CODEX_BETA=0 (emergency rollback).
+        const gated = { ...providers };
+        if (isCodexBetaDisabled())
+            gated.codex = false;
+        // 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) => {
         const status = (0, setup_prerequisites_1.getSetupPrerequisitesStatus)();
@@ -218,6 +233,12 @@ function createDesktopRouter(registry, broadcast) {
             });
             return;
         }
+        if (providers.includes('gemini') && isGeminiBetaDisabled()) {
+            res.status(400).json({
+                error: 'Gemini provider is currently disabled (SPECRAILS_GEMINI_BETA=0). Unset or set to 1 to enable.',
+            });
+            return;
+        }
         const resolvedPath = path_1.default.resolve(projectPath);
         // Validate path exists
         if (!fs_1.default.existsSync(resolvedPath)) {
@@ -243,7 +264,7 @@ function createDesktopRouter(registry, broadcast) {
                 name: derivedName,
                 path: canonicalPath,
                 provider: providers[0],
-                providers: providers,
+                providers,
             });
             broadcast({
                 type: 'desktop.project_added',

package/server/dist/explore-cwd-manager.js

@@ -127,7 +127,7 @@ function ensureExploreCwd(input, baseDir) {
     // — provider is immutable post-creation but the lifecycle code MUST handle
     // the edge per spec), remove any stale instructions file authored by a
     // different provider so the explore-cwd doesn't carry both.
-    const STALE_INSTRUCTION_FILES = ['CLAUDE.md', 'AGENTS.md'];
+    const STALE_INSTRUCTION_FILES = ['CLAUDE.md', 'AGENTS.md', 'GEMINI.md'];
     for (const stale of STALE_INSTRUCTION_FILES) {
         if (stale === adapter.instructionsFilename)
             continue;

package/server/dist/mobile/mobile-datachannel.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DataChannelPeer = exports.DataChannelSocket = void 0;
+exports.DataChannelPeer = exports.DataChannelSocket = exports.ChunkReassembler = void 0;
 // WebRTC DataChannel transport for the web companion (serverless double-QR
 // pairing). Instead of a LAN WSS gateway, the companion connects peer-to-peer
 // over a WebRTC DataChannel; this module bridges that channel onto the EXISTING
@@ -15,6 +15,63 @@ exports.DataChannelPeer = exports.DataChannelSocket = void 0;
 // without a real WebRTC stack, the database, or the loopback HTTP forward.
 const WS_OPEN = 1;
 const WS_CLOSED = 3;
+// WebRTC DataChannels carry an SCTP per-message size cap (werift advertises a
+// modest maxMessageSize; oversized sends throw). A large rpc_result — e.g. a
+// JIRA-backed project's full ticket list — easily exceeds it, and the throw was
+// swallowed silently, so the companion just timed out and rendered "0 tickets".
+// We split any oversized frame into ordered `__chunk` envelopes and reassemble
+// them on the far side. The channel is ordered+reliable, so chunks arrive in
+// order; `g` (group id) keeps concurrent large messages from interleaving.
+const CHUNK_SIZE = 16000;
+let _chunkGroup = 0;
+/** Send `data` over `ch`, splitting into `__chunk` frames when it exceeds the
+ *  safe per-message size. Small frames go out verbatim (no envelope overhead). */
+function framedSend(ch, data) {
+    if (data.length <= CHUNK_SIZE) {
+        ch.send(data);
+        return;
+    }
+    const g = _chunkGroup++;
+    const n = Math.ceil(data.length / CHUNK_SIZE);
+    for (let i = 0; i < n; i++) {
+        const d = data.slice(i * CHUNK_SIZE, (i + 1) * CHUNK_SIZE);
+        ch.send(JSON.stringify({ type: '__chunk', g, i, n, d }));
+    }
+}
+/** Buffers inbound `__chunk` frames and yields the reassembled payload once a
+ *  group is complete. Non-chunk frames pass straight through. */
+class ChunkReassembler {
+    _groups = new Map();
+    /** Returns the string to handle (the frame itself, or a completed
+     *  reassembly), or null when more chunks of the group are still pending. */
+    push(data) {
+        if (!data.startsWith('{"type":"__chunk"'))
+            return data;
+        let p;
+        try {
+            p = JSON.parse(data);
+        }
+        catch {
+            return data;
+        }
+        if (!p || p.n == null)
+            return data;
+        let grp = this._groups.get(p.g);
+        if (!grp) {
+            grp = { n: p.n, parts: new Array(p.n).fill(''), got: 0 };
+            this._groups.set(p.g, grp);
+        }
+        if (grp.parts[p.i] === '' && grp.got < grp.n) {
+            grp.parts[p.i] = p.d;
+            grp.got++;
+        }
+        if (grp.got < grp.n)
+            return null;
+        this._groups.delete(p.g);
+        return grp.parts.join('');
+    }
+}
+exports.ChunkReassembler = ChunkReassembler;
 /** Presents a DataChannel to MobileWsBridge as if it were a ws.WebSocket, so the
  *  existing fan-out (redaction, per-subscription filtering, log batching) is
  *  reused unchanged. WebRTC has no ping/pong frames, so ping() reports liveness
@@ -30,7 +87,7 @@ class DataChannelSocket {
     }
     send(data) {
         try {
-            this._ch.send(data);
+            framedSend(this._ch, data);
         }
         catch {
             /* channel went away mid-send — onClose will reap it */
@@ -88,12 +145,16 @@ class DataChannelPeer {
     _sock;
     _authed = false;
     _token = '';
+    _reasm = new ChunkReassembler();
     constructor(_ch, _deps) {
         this._ch = _ch;
         this._deps = _deps;
         this._sock = new DataChannelSocket(_ch);
         _ch.onMessage((data) => {
-            void this._onMessage(data);
+            const full = this._reasm.push(data);
+            if (full === null)
+                return;
+            void this._onMessage(full);
         });
         _ch.onClose(() => this._sock.closed());
     }
@@ -102,7 +163,7 @@ class DataChannelPeer {
     }
     _send(obj) {
         try {
-            this._ch.send(JSON.stringify(obj));
+            framedSend(this._ch, JSON.stringify(obj));
         }
         catch {
             /* ignore */

package/server/dist/pricing.js

@@ -32,6 +32,19 @@ exports.PRICING = {
     'codex:gpt-5.4': { inputPer1M: 2.50, outputPer1M: 10.00, cacheReadPer1M: 0.25, lastReviewedAt: '2026-05-17' },
     'codex:gpt-5.4-mini': { inputPer1M: 0.25, outputPer1M: 2.00, cacheReadPer1M: 0.025, lastReviewedAt: '2026-05-17' },
     'codex:gpt-5.3-codex': { inputPer1M: 1.50, outputPer1M: 6.00, cacheReadPer1M: 0.15, lastReviewedAt: '2026-05-17' },
+    // Gemini (Google). Reference: https://ai.google.dev/gemini-api/docs/pricing
+    // Standard paid tier, <=200k-context prices (Gemini Pro is context-tiered;
+    // prompts >200k are under-estimated in v1 — see docs/gemini-cli-provider-study.md §2).
+    // Current catalog (June 2026): 3.5-flash flagship default, 3.1-pro-preview max,
+    // 3.1-flash-lite budget, 2.5-flash-lite cheapest. Older 2.5-pro/2.5-flash rows
+    // are retained so historic invocations still price.
+    'gemini:gemini-3.5-flash': { inputPer1M: 1.50, outputPer1M: 9.00, cacheReadPer1M: 0.15, lastReviewedAt: '2026-06-17' },
+    'gemini:gemini-3.1-pro-preview': { inputPer1M: 2.00, outputPer1M: 12.00, cacheReadPer1M: 0.20, lastReviewedAt: '2026-06-17' },
+    'gemini:gemini-3.1-flash-lite': { inputPer1M: 0.25, outputPer1M: 1.50, cacheReadPer1M: 0.025, lastReviewedAt: '2026-06-17' },
+    'gemini:gemini-3-flash-preview': { inputPer1M: 0.50, outputPer1M: 3.00, cacheReadPer1M: 0.05, lastReviewedAt: '2026-06-17' },
+    'gemini:gemini-2.5-pro': { inputPer1M: 1.25, outputPer1M: 10.00, cacheReadPer1M: 0.125, lastReviewedAt: '2026-06-17' },
+    'gemini:gemini-2.5-flash': { inputPer1M: 0.30, outputPer1M: 2.50, cacheReadPer1M: 0.03, lastReviewedAt: '2026-06-17' },
+    'gemini:gemini-2.5-flash-lite': { inputPer1M: 0.10, outputPer1M: 0.40, cacheReadPer1M: 0.01, lastReviewedAt: '2026-06-17' },
 };
 /**
  * Estimate cost in USD from a token usage breakdown. Returns `null` when:

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

@@ -393,24 +393,44 @@ function registerTicketsRoutes(deps) {
                 broadcast(msg);
                 return;
             }
-            // Claude path.
-            if (parsed.type === 'result') {
+            if (provider === 'claude') {
+                // Claude path.
+                if (parsed.type === 'result') {
+                    lastResultEvent = parsed;
+                }
+                if (parsed.type === 'assistant') {
+                    const msg = parsed.message;
+                    const texts = (msg?.content ?? [])
+                        .filter((c) => c.type === 'text')
+                        .map((c) => c.text ?? '');
+                    const newText = texts.join('');
+                    if (newText) {
+                        buffer += newText;
+                        const wsMsg = {
+                            type: 'spec_gen_stream', projectId, requestId,
+                            delta: newText, timestamp: new Date().toISOString(),
+                        };
+                        broadcast(wsMsg);
+                    }
+                }
+                return;
+            }
+            // Adapter-driven path (gemini + future providers): the adapter already
+            // parsed this line into a structured AdapterEvent above (`adapterEv`).
+            // Accumulate assistant text deltas into the buffer and capture the result
+            // event for usage extraction — mirrors the ai-edit endpoint's else branch.
+            // Without this, gemini (which emits `type:'message'`, not `type:'assistant'`)
+            // would never accumulate text → empty buffer → "Empty response from AI".
+            if (adapterEv?.kind === 'result') {
                 lastResultEvent = parsed;
             }
-            if (parsed.type === 'assistant') {
-                const msg = parsed.message;
-                const texts = (msg?.content ?? [])
-                    .filter((c) => c.type === 'text')
-                    .map((c) => c.text ?? '');
-                const newText = texts.join('');
-                if (newText) {
-                    buffer += newText;
-                    const wsMsg = {
-                        type: 'spec_gen_stream', projectId, requestId,
-                        delta: newText, timestamp: new Date().toISOString(),
-                    };
-                    broadcast(wsMsg);
-                }
+            if (adapterEv?.kind === 'text-delta' && adapterEv.text) {
+                buffer += adapterEv.text;
+                const wsMsg = {
+                    type: 'spec_gen_stream', projectId, requestId,
+                    delta: adapterEv.text, timestamp: new Date().toISOString(),
+                };
+                broadcast(wsMsg);
             }
         });
         child.on('close', async (code) => {
@@ -1476,7 +1496,7 @@ function registerTicketsRoutes(deps) {
             // Use gpt-5.5 (default for Codex per CODEX_MODELS/PRESET_DEFAULTS in ModelSelector); never hardcode o4-mini
             args = ['exec', `${systemPrompt}\n\n${userPrompt}`, '--model', 'gpt-5.5'];
         }
-        else {
+        else if (provider === 'claude') {
             binary = 'claude';
             args = [
                 '--dangerously-skip-permissions',
@@ -1489,6 +1509,18 @@ function registerTicketsRoutes(deps) {
                 '-p', userPrompt,
             ];
         }
+        else {
+            // Adapter-driven path (gemini + any future provider): binary, argv, and
+            // stream parsing all come from the registered adapter — no per-provider
+            // hardcoding. The claude/codex shapes above are kept byte-identical.
+            const adapter = (0, providers_1.getAdapter)(provider);
+            binary = adapter.binary;
+            args = adapter.buildArgs('agent-refine', {
+                prompt: userPrompt,
+                systemPrompt,
+                model: adapter.defaultModel(),
+            });
+        }
         // spawnAiCli reroutes multi-line argv values through stdin on Windows.
         console.log(`[project-router] ai-edit spawn: ${binary} (cwd=${project.path}, requestId=${requestId})`);
         const child = (0, cli_prompt_1.spawnAiCli)(binary, args, {
@@ -1534,7 +1566,7 @@ function registerTicketsRoutes(deps) {
                     broadcast(msg);
                 }
             }
-            else {
+            else if (provider === 'claude') {
                 let parsed = null;
                 try {
                     parsed = JSON.parse(line);
@@ -1558,6 +1590,19 @@ function registerTicketsRoutes(deps) {
                     }
                 }
             }
+            else {
+                // Adapter-driven parse (gemini + future providers): uniform AdapterEvent
+                // stream — accumulate assistant text deltas.
+                const ev = (0, providers_1.getAdapter)(provider).parseStreamLine(line);
+                if (ev?.kind === 'text-delta' && ev.text) {
+                    buffer += ev.text;
+                    const wsMsg = {
+                        type: 'ticket_ai_edit_stream', projectId, ticketId: Number(ticketId),
+                        requestId, delta: ev.text, timestamp: new Date().toISOString(),
+                    };
+                    broadcast(wsMsg);
+                }
+            }
         });
         child.on('close', (code) => {
             _aiEditProcesses.delete(requestId);

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

@@ -0,0 +1,238 @@
+"use strict";
+// Gemini CLI (Google) adapter for gemini-cli 0.11.0+.
+//
+// Stream format (gemini `-p "<prompt>" --output-format stream-json`), one minified
+// JSON object per line — pinned to gemini-cli >= 0.11 and locked by the fixtures
+// under __fixtures__/gemini-*.ndjson:
+//   {"type":"init","session_id":"<UUID>","model":"gemini-3.5-flash"}
+//   {"type":"message","role":"assistant","content":"...","delta":true}
+//   {"type":"tool_use","tool_name":"read_file","tool_id":"t0","parameters":{...}}
+//   {"type":"tool_result","tool_id":"t0","status":"ok","output":"..."}
+//   {"type":"result","status":"success","stats":{"input_tokens":N,"output_tokens":N,
+//     "cached":N,"total_tokens":N,"duration_ms":N}}
+//
+// Differences vs codex: Gemini reports tokens but NOT cost, so `nativeCostUsd`
+// is false and cost is estimated downstream via server/pricing.ts. Gemini DOES
+// emit OTLP natively via `GEMINI_TELEMETRY_*` env (set by QueueManager), so
+// `nativeOtelEnv` is true — no synthetic bridge. There is no `--system-prompt`
+// flag (the CLI uses the `GEMINI_SYSTEM_MD` env), so `systemPromptArg` is false
+// and the system prompt is folded for non-Explore actions; Explore turns trust
+// the app-managed GEMINI.md in explore-cwd, exactly like codex/AGENTS.md.
+//
+// NOTE (pre-1.0): gemini-cli changes weekly. The exact argv/event field names
+// here follow the documented 0.11 contract; they are guarded by the beta flag
+// (SPECRAILS_GEMINI_BETA) and MUST be re-validated against a real binary via the
+// fixtures before the gate is removed. Parsing is tolerant of missing fields.
+//
+// Spec: openspec/specs/multi-provider-architecture/spec.md
+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';
+exports._GEMINI_MIN_VERSION = GEMINI_MIN_VERSION;
+// Curated GA-id catalog (see docs/gemini-cli-provider-study.md §2). Preview ids
+// rotate, so we pin concrete ids that pricing.ts has rows for.
+const GEMINI_MODELS = [
+    { value: 'gemini-3.5-flash', label: 'Gemini 3.5 Flash', default: true },
+    { value: 'gemini-3.1-pro-preview', label: 'Gemini 3.1 Pro (preview)' },
+    { value: 'gemini-3.1-flash-lite', label: 'Gemini 3.1 Flash Lite' },
+    { value: 'gemini-2.5-flash-lite', label: 'Gemini 2.5 Flash Lite' },
+];
+const STREAM_JSON_FLAGS = ['--output-format', 'stream-json'];
+// Auto-approve tool calls so headless turns never block on an approval prompt.
+// Parity with codex's workspace-write/full-access sandbox; the non-destructive
+// stance for Explore is carried by GEMINI.md + the system prompt, not a sandbox.
+const YOLO_FLAG = '--yolo';
+/** Fold system prompt into the user prompt for providers without --system-prompt. */
+function fold(systemPrompt, prompt) {
+    if (!systemPrompt)
+        return prompt;
+    return `${systemPrompt}\n\n---\n\n${prompt}`;
+}
+function buildGeminiArgs(action, opts) {
+    const model = ['--model', opts.model];
+    switch (action) {
+        case 'chat-turn': {
+            // Explore turns spawn from the app-managed explore-cwd, which ships a
+            // GEMINI.md with the Explore stance. Folding the long system prompt into a
+            // short user message ("quiero hacer un tetris") makes the model answer the
+            // system instructions instead of the user — so pass user text only and
+            // trust GEMINI.md, exactly like the codex adapter trusts AGENTS.md.
+            return ['-p', opts.prompt, ...model, ...STREAM_JSON_FLAGS, YOLO_FLAG, ...(opts.extraArgs ?? [])];
+        }
+        case 'chat-resume': {
+            if (!opts.sessionId)
+                throw new Error(`${action} requires sessionId`);
+            return ['-p', opts.prompt, ...model, ...STREAM_JSON_FLAGS, '--resume', opts.sessionId, YOLO_FLAG, ...(opts.extraArgs ?? [])];
+        }
+        case 'chat-stream': {
+            // Gemini has no persistent-stdin multi-turn transport; the Explore
+            // fast-path gates on capabilities.persistentStdin (omitted), so this is
+            // never reached. Throw defensively rather than emit a broken argv.
+            throw new Error('gemini does not support persistent stdin streaming (chat-stream)');
+        }
+        case 'spec-gen':
+        case 'agent-refine':
+        case 'auto-title':
+        case 'setup-enrich':
+        case 'rail-job': {
+            return ['-p', fold(opts.systemPrompt, opts.prompt), ...model, ...STREAM_JSON_FLAGS, YOLO_FLAG, ...(opts.extraArgs ?? [])];
+        }
+        case 'setup-enrich-resume': {
+            if (!opts.sessionId)
+                throw new Error(`${action} requires sessionId`);
+            return ['-p', fold(opts.systemPrompt, opts.prompt), ...model, ...STREAM_JSON_FLAGS, '--resume', opts.sessionId, YOLO_FLAG, ...(opts.extraArgs ?? [])];
+        }
+    }
+}
+function parseGeminiStreamLine(line) {
+    if (line.length === 0)
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+    const type = parsed.type;
+    if (!type)
+        return { kind: 'other', type: '<missing>', raw: parsed };
+    if (type === 'init') {
+        const sid = parsed.session_id;
+        if (sid)
+            return { kind: 'session-started', sessionId: sid };
+        return { kind: 'other', type, raw: parsed };
+    }
+    if (type === 'result') {
+        return { kind: 'result', payload: parsed };
+    }
+    if (type === 'message') {
+        // Only assistant text is a delta; the user echo (role 'user') is ignored.
+        const role = parsed.role;
+        if (role === 'assistant') {
+            const text = parsed.content ?? '';
+            if (text)
+                return { kind: 'text-delta', text };
+        }
+        return { kind: 'other', type, raw: parsed };
+    }
+    if (type === 'tool_use') {
+        const name = parsed.tool_name ?? '<unnamed>';
+        const params = parsed.parameters;
+        const inputPreview = params !== undefined ? JSON.stringify(params).slice(0, 200) : '';
+        return { kind: 'tool-use', name, inputPreview };
+    }
+    // tool_result, error, and any unknown event type carry no normalised meaning.
+    return { kind: 'other', type, raw: parsed };
+}
+function extractGeminiResult(events) {
+    let sessionId;
+    let resultPayload = null;
+    let turnCount = 0;
+    for (const ev of events) {
+        if (ev.kind === 'session-started')
+            sessionId = ev.sessionId;
+        else if (ev.kind === 'result') {
+            resultPayload = ev.payload;
+            turnCount += 1;
+        }
+    }
+    if (!resultPayload) {
+        return { session_id: sessionId };
+    }
+    const stats = resultPayload.stats;
+    return {
+        tokens_in: stats?.input_tokens,
+        tokens_out: stats?.output_tokens,
+        // Gemini reports a single `cached` read tier; map it to cache_read. No
+        // separate cache-creation tier — `cached` is counted as a subset of
+        // input_tokens (consistent with codex `cached_input_tokens`), so pricing.ts
+        // must not double-count.
+        tokens_cache_read: stats?.cached,
+        tokens_cache_create: undefined,
+        // total_cost_usd intentionally absent — estimated via pricing.ts.
+        num_turns: turnCount || 1,
+        // Stream events do not carry the model; the manager wrapper stamps the
+        // requested model on the row.
+        model: undefined,
+        duration_ms: typeof stats?.duration_ms === 'number' ? stats.duration_ms : undefined,
+        duration_api_ms: undefined,
+        session_id: sessionId,
+    };
+}
+function compareSemver(a, b) {
+    const aParts = a.split('.').map((n) => parseInt(n, 10));
+    const bParts = b.split('.').map((n) => parseInt(n, 10));
+    for (let i = 0; i < 3; i++) {
+        const av = aParts[i] ?? 0;
+        const bv = bParts[i] ?? 0;
+        if (av > bv)
+            return 1;
+        if (av < bv)
+            return -1;
+    }
+    return 0;
+}
+async function detectGeminiInstalled() {
+    try {
+        (0, child_process_1.execSync)(`${WHICH_CMD} gemini`, { stdio: 'ignore' });
+    }
+    catch {
+        return { installed: false, executable: false };
+    }
+    try {
+        const raw = (0, child_process_1.execSync)('gemini --version', {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'ignore'],
+            timeout: 3000,
+        }).trim();
+        const match = raw.match(/\d+\.\d+\.\d+/);
+        const version = match ? match[0] : raw;
+        const meetsMinimum = match ? compareSemver(version, GEMINI_MIN_VERSION) >= 0 : false;
+        const result = {
+            installed: true,
+            executable: true,
+            version,
+            meetsMinimum,
+        };
+        if (!meetsMinimum) {
+            result.error = `gemini ${version} is older than required ${GEMINI_MIN_VERSION}. Upgrade with: npm i -g @google/gemini-cli (or see https://github.com/google-gemini/gemini-cli).`;
+        }
+        return result;
+    }
+    catch {
+        return { installed: true, executable: false };
+    }
+}
+exports.geminiAdapter = {
+    id: 'gemini',
+    displayName: 'Gemini CLI',
+    binary: 'gemini',
+    minCliVersion: GEMINI_MIN_VERSION,
+    projectDirName: '.gemini',
+    instructionsFilename: 'GEMINI.md',
+    mcpRegistration: 'project-json',
+    capabilities: {
+        nativeResume: true,
+        nativeStreamJson: true,
+        nativeCostUsd: false,
+        nativeOtelEnv: true,
+        profileEnvSupport: true,
+        systemPromptArg: false,
+    },
+    modelCatalog: () => GEMINI_MODELS,
+    defaultModel: () => 'gemini-3.5-flash',
+    buildArgs: buildGeminiArgs,
+    parseStreamLine: parseGeminiStreamLine,
+    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/providers/index.js

@@ -7,14 +7,17 @@
 //
 // Spec: openspec/specs/multi-provider-architecture/spec.md
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnknownProviderError = exports.codexAdapter = exports.claudeAdapter = exports.listAdapters = exports.hasAdapter = exports.getAdapter = void 0;
+exports.UnknownProviderError = exports.geminiAdapter = exports.codexAdapter = exports.claudeAdapter = exports.listAdapters = exports.hasAdapter = exports.getAdapter = void 0;
 const registry_1 = require("./registry");
 const claude_adapter_1 = require("./claude-adapter");
 Object.defineProperty(exports, "claudeAdapter", { enumerable: true, get: function () { return claude_adapter_1.claudeAdapter; } });
 const codex_adapter_1 = require("./codex-adapter");
 Object.defineProperty(exports, "codexAdapter", { enumerable: true, get: function () { return codex_adapter_1.codexAdapter; } });
+const gemini_adapter_1 = require("./gemini-adapter");
+Object.defineProperty(exports, "geminiAdapter", { enumerable: true, get: function () { return gemini_adapter_1.geminiAdapter; } });
 (0, registry_1.register)(claude_adapter_1.claudeAdapter);
 (0, registry_1.register)(codex_adapter_1.codexAdapter);
+(0, registry_1.register)(gemini_adapter_1.geminiAdapter);
 var registry_2 = require("./registry");
 Object.defineProperty(exports, "getAdapter", { enumerable: true, get: function () { return registry_2.getAdapter; } });
 Object.defineProperty(exports, "hasAdapter", { enumerable: true, get: function () { return registry_2.hasAdapter; } });