specrails-desktop 2.5.0 → 2.7.0

package/server/dist/mobile/mobile-webrtc-peer.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MobileWebrtcGateway = void 0;
+const werift_1 = require("werift");
+const auth_1 = require("../auth");
+const mobile_datachannel_1 = require("./mobile-datachannel");
+class MobileWebrtcGateway {
+    _deps;
+    _pending = null;
+    _active = new Set();
+    constructor(_deps) {
+        this._deps = _deps;
+    }
+    /** Drop the open (un-answered) offer. */
+    clearOffer() {
+        const p = this._pending;
+        this._pending = null;
+        if (p)
+            this._close(p.pc);
+    }
+    /** Create a fresh pairing offer (peer + DataChannel + gathered offer SDP).
+     *  Replaces any previously-open offer. Returns the SDP to embed in the QR. */
+    async createOffer(secret) {
+        this.clearOffer();
+        const pc = new werift_1.RTCPeerConnection({ iceServers: [] });
+        const dc = pc.createDataChannel('mobile');
+        // The companion peer activates when the channel opens. It validates `hello`
+        // against THIS connection's offer secret (captured in this closure) — not a
+        // global pending secret, which is already null by the time hello arrives.
+        new mobile_datachannel_1.DataChannelPeer(toChannelLike(dc), {
+            registerDevice: async (input) => input.secret && (0, auth_1.safeEqual)(input.secret, secret)
+                ? this._deps.registerDevice({ deviceName: input.deviceName, platform: input.platform, token: input.token })
+                : { ok: false },
+            rpcDispatch: this._deps.rpcDispatch,
+            bridge: this._deps.bridge,
+        });
+        pc.connectionStateChange.subscribe((s) => {
+            console.log('[webrtc] pc connectionState:', s);
+            if (s === 'failed' || s === 'closed' || s === 'disconnected') {
+                this._active.delete(pc);
+                if (this._pending?.pc === pc)
+                    this._pending = null;
+            }
+        });
+        const offer = await pc.createOffer();
+        await pc.setLocalDescription(offer);
+        await waitIceComplete(pc);
+        const sdp = pc.localDescription?.sdp;
+        if (!sdp) {
+            this._close(pc);
+            throw new Error('no local description after ICE gathering');
+        }
+        console.log(`[webrtc] offer ready: ${(sdp.match(/a=candidate/g) ?? []).length} ICE candidates`);
+        this._pending = { pc, secret };
+        return { sdp };
+    }
+    /** Apply the companion's scanned answer SDP to the open offer and keep the
+     *  connection alive for the session. */
+    async acceptAnswer(sdp) {
+        const p = this._pending;
+        if (!p)
+            return { ok: false };
+        try {
+            console.log(`[webrtc] applying answer: ${(sdp.match(/a=candidate/g) ?? []).length} ICE candidates`);
+            await p.pc.setRemoteDescription({ type: 'answer', sdp });
+            this._active.add(p.pc);
+            this._pending = null;
+            return { ok: true };
+        }
+        catch {
+            return { ok: false };
+        }
+    }
+    /** Tear down every peer (gateway stopping / disabled). */
+    stop() {
+        this.clearOffer();
+        for (const pc of this._active)
+            this._close(pc);
+        this._active.clear();
+    }
+    _close(pc) {
+        try {
+            void pc.close();
+        }
+        catch {
+            /* ignore */
+        }
+    }
+}
+exports.MobileWebrtcGateway = MobileWebrtcGateway;
+function toChannelLike(dc) {
+    dc.stateChanged.subscribe((s) => console.log('[webrtc] datachannel state:', s));
+    return {
+        get readyState() {
+            return dc.readyState;
+        },
+        send: (data) => dc.send(data),
+        onMessage: (cb) => {
+            dc.onMessage.subscribe((d) => cb(typeof d === 'string' ? d : d.toString('utf8')));
+        },
+        onClose: (cb) => {
+            dc.stateChanged.subscribe((s) => {
+                if (s === 'closed')
+                    cb();
+            });
+        },
+    };
+}
+/** Vanilla ICE: resolve once gathering completes so the offer SDP carries all
+ *  candidates (there's no trickle channel — the SDP travels by QR). */
+function waitIceComplete(pc) {
+    if (pc.iceGatheringState === 'complete')
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        let done = false;
+        const finish = () => {
+            if (!done) {
+                done = true;
+                resolve();
+            }
+        };
+        pc.iceGatheringStateChange.subscribe((s) => {
+            if (s === 'complete')
+                finish();
+        });
+        const t = setTimeout(finish, 3000);
+        t.unref?.();
+    });
+}

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

@@ -0,0 +1,117 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildRegisterDevice = buildRegisterDevice;
+exports.buildRpcDispatch = buildRpcDispatch;
+exports.createLoopbackFetch = createLoopbackFetch;
+const https_1 = __importDefault(require("https"));
+const crypto_1 = require("crypto");
+const mobile_devices_1 = require("./mobile-devices");
+// Glue for the serverless WebRTC companion, kept dependency-injected so the
+// security-relevant bits (secret check, device creation, /v1 dispatch) are
+// unit-tested without a real WebRTC peer, the DB driver, or HTTP. The werift
+// runtime peer lives in ./mobile-webrtc-peer.ts and consumes these.
+function toPlatform(p) {
+    return p === 'android' ? 'android' : p === 'ios' ? 'ios' : 'web';
+}
+/** Persists a paired device + issues its token. The single-use pairing-secret
+ *  check is done per-connection by [MobileWebrtcGateway] (which holds each
+ *  offer's secret for the life of that connection — the secret must NOT live on
+ *  the global "pending offer", which is cleared the moment the answer is
+ *  accepted, well before the companion's `hello` arrives). Approval is implicit:
+ *  the desktop user actively scanned the phone's answer QR. */
+function buildRegisterDevice(deps) {
+    const genToken = deps.genToken ?? (() => (0, crypto_1.randomBytes)(32).toString('hex'));
+    return async (input) => {
+        // Reconnect: a known, non-revoked device token → reuse that device (no new
+        // row, no growing the paired-devices list on every reconnect).
+        if (input.token) {
+            const existing = (0, mobile_devices_1.getActiveDeviceByTokenHash)(deps.db, (0, mobile_devices_1.hashToken)(input.token));
+            if (existing) {
+                return {
+                    ok: true,
+                    deviceId: existing.id,
+                    token: input.token,
+                    hubName: deps.desktopName(),
+                    hubInstanceId: deps.desktopInstanceId(),
+                };
+            }
+        }
+        const token = genToken();
+        const row = (0, mobile_devices_1.createDevice)(deps.db, {
+            name: (input.deviceName || 'Web companion').slice(0, 80),
+            platform: toPlatform(input.platform),
+            tokenHash: (0, mobile_devices_1.hashToken)(token),
+            certFingerprint: deps.currentFingerprint(),
+        });
+        return {
+            ok: true,
+            deviceId: row.id,
+            token,
+            hubName: deps.desktopName(),
+            hubInstanceId: deps.desktopInstanceId(),
+        };
+    };
+}
+/** Builds the `rpcDispatch` used by [DataChannelPeer] on `rpc`. A thin proxy to
+ *  the EXISTING `/v1` allow-list (which already validates params, forwards to the
+ *  internal API, and redacts), authenticated with the device's bearer token. */
+function buildRpcDispatch(deps) {
+    return async (input) => {
+        // Only the /v1 surface is reachable; the gateway enforces the allow-list.
+        if (input.path !== '/v1' && !input.path.startsWith('/v1/')) {
+            return { status: 404, json: { error: 'not found' } };
+        }
+        const method = input.method.toUpperCase();
+        const headers = { Authorization: `Bearer ${input.token}` };
+        let body;
+        if (input.body !== undefined && method !== 'GET' && method !== 'DELETE') {
+            headers['Content-Type'] = 'application/json';
+            body = JSON.stringify(input.body);
+        }
+        try {
+            const res = await deps.doFetch(deps.gatewayBase + input.path, { method, headers, body });
+            const text = await res.text();
+            let json = {};
+            try {
+                json = text ? JSON.parse(text) : {};
+            }
+            catch {
+                json = {};
+            }
+            return { status: res.status, json };
+        }
+        catch {
+            return { status: 502, json: { error: 'gateway unreachable' } };
+        }
+    };
+}
+/** A loopback `fetch` for the local /v1 gateway. It deliberately ignores the
+ *  gateway's self-signed cert — the connection never leaves 127.0.0.1, and the
+ *  device bearer token (not the TLS cert) is the auth boundary. */
+function createLoopbackFetch() {
+    return (url, init) => new Promise((resolve, reject) => {
+        const u = new URL(url);
+        const req = https_1.default.request({
+            hostname: u.hostname,
+            port: u.port,
+            path: u.pathname + u.search,
+            method: init.method,
+            headers: init.headers,
+            rejectUnauthorized: false,
+        }, (res) => {
+            let data = '';
+            res.setEncoding('utf8');
+            res.on('data', (c) => {
+                data += c;
+            });
+            res.on('end', () => resolve({ status: res.statusCode ?? 0, text: async () => data }));
+        });
+        req.on('error', reject);
+        if (init.body)
+            req.write(init.body);
+        req.end();
+    });
+}

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,234 @@
+"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 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,
+};

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; } });