circuschief 1.0.0 → 1.1.0

package/packages/server/src/db/migrations/providerMigrations.js

@@ -1,4 +1,4 @@
-import { OPENAI_MODELS } from '../../../../shared/src/index.js';
+import { OPENAI_MODELS, GEMINI_MODELS } from '../../../../shared/src/index.js';
 import { addColumnIfMissing, tableExists } from './migrationUtils.js';
 
 function seedBuiltInAnthropicProvider(db) {
@@ -54,6 +54,27 @@ function seedBuiltInOpenAIProvider(db) {
   }
 }
 
+function seedBuiltInGoogleProvider(db) {
+  const providerId = 'google-default';
+  const now = Date.now();
+
+  db.prepare(
+    `INSERT OR IGNORE INTO providers (
+       id, name, base_url, auth_token, kind, is_built_in, created_at, updated_at
+     )
+     VALUES (?, ?, NULL, NULL, 'google', 1, ?, ?)`
+  ).run(providerId, 'Google (Official)', now, now);
+
+  const insertModel = db.prepare(
+    `INSERT OR IGNORE INTO provider_models (id, provider_id, model_id, display_name, description, tier, created_at)
+     VALUES (?, ?, ?, ?, ?, 'custom', ?)`
+  );
+
+  for (const model of GEMINI_MODELS) {
+    insertModel.run(model.seedId, providerId, model.id, model.name, model.description, now);
+  }
+}
+
 function seedBuiltInProviders(db) {
   seedBuiltInAnthropicProvider(db);
   seedBuiltInOpenAIProvider(db);
@@ -98,7 +119,7 @@ export const providerMigrations = [
           additional_env_vars TEXT,
           commit_attribution_override TEXT,
           is_built_in INTEGER NOT NULL DEFAULT 0,
-          kind TEXT NOT NULL DEFAULT 'anthropic' CHECK(kind IN ('anthropic','openai')),
+          kind TEXT NOT NULL DEFAULT 'anthropic' CHECK(kind IN ('anthropic','openai','google')),
           created_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
           updated_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
         );
@@ -123,7 +144,7 @@ export const providerMigrations = [
         db,
         'providers',
         'kind',
-        "TEXT NOT NULL DEFAULT 'anthropic' CHECK(kind IN ('anthropic','openai'))"
+        "TEXT NOT NULL DEFAULT 'anthropic' CHECK(kind IN ('anthropic','openai','google'))"
       );
     },
   },
@@ -162,4 +183,68 @@ export const providerMigrations = [
       ).run('anthropic-opus-4-7', providerId, 'claude-opus-4-7', 'Opus 4.7', 'Most capable (default)', 'opus', Date.now());
     },
   },
+  {
+    name: 'providers-widen-kind-check-google',
+    up(db) {
+      // SQLite CHECK constraints are baked into the table definition and can't
+      // be altered in-place. Recreate the table with the wider CHECK.
+      //
+      // IMPORTANT: Disable foreign key enforcement during the table swap.
+      // provider_models has ON DELETE CASCADE referencing providers. SQLite
+      // fires that cascade when DROP TABLE deletes parent rows, which would
+      // wipe all provider_models data. Disabling FK enforcement prevents the
+      // cascade. We re-enable it immediately after the rename.
+      db.pragma('foreign_keys = OFF');
+      try {
+        db.exec(`
+          CREATE TABLE IF NOT EXISTS providers_new (
+            id TEXT PRIMARY KEY,
+            name TEXT NOT NULL,
+            base_url TEXT,
+            auth_token TEXT,
+            api_timeout_ms INTEGER,
+            additional_env_vars TEXT,
+            commit_attribution_override TEXT,
+            is_built_in INTEGER NOT NULL DEFAULT 0,
+            kind TEXT NOT NULL DEFAULT 'anthropic' CHECK(kind IN ('anthropic','openai','google')),
+            created_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+            updated_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
+          );
+
+          INSERT OR IGNORE INTO providers_new SELECT * FROM providers;
+
+          DROP TABLE providers;
+
+          ALTER TABLE providers_new RENAME TO providers;
+
+          CREATE INDEX IF NOT EXISTS idx_provider_models_provider ON provider_models(provider_id);
+        `);
+      } finally {
+        db.pragma('foreign_keys = ON');
+      }
+    },
+  },
+  {
+    name: 'providers-seed-built-in-google',
+    up(db) { seedBuiltInGoogleProvider(db); },
+  },
+  {
+    name: 'providers-update-gemini-flash-lite-model',
+    up(db) {
+      // The preview model 'gemini-2.5-flash-lite-preview-06-17' has been
+      // removed by Google. Update to the stable GA model ID.
+      db.prepare(
+        `UPDATE provider_models
+         SET model_id = ?, description = ?
+         WHERE id = ? AND provider_id = ?`
+      ).run('gemini-2.5-flash-lite', 'Lightweight & cost-efficient', 'google-gemini-2-5-flash-lite', 'google-default');
+
+      // Also update any sessions that were using the old model ID
+      db.prepare(
+        `UPDATE sessions
+         SET model = ?
+         WHERE model = ?`
+      ).run('gemini-2.5-flash-lite', 'gemini-2.5-flash-lite-preview-06-17');
+    },
+  },
 ];

package/packages/server/src/db/seedBaselineData.js

@@ -1,5 +1,5 @@
 import { randomUUID } from 'node:crypto';
-import { OPENAI_MODELS } from '../../../shared/src/index.js';
+import { OPENAI_MODELS, GEMINI_MODELS } from '../../../shared/src/index.js';
 
 export const BUILT_IN_ANTHROPIC_PROVIDER = {
   id: 'anthropic-default',
@@ -13,6 +13,12 @@ export const BUILT_IN_OPENAI_PROVIDER = {
   kind: 'openai',
 };
 
+export const BUILT_IN_GOOGLE_PROVIDER = {
+  id: 'google-default',
+  name: 'Google (Official)',
+  kind: 'google',
+};
+
 export const BUILT_IN_ANTHROPIC_MODELS = [
   { id: 'anthropic-haiku', providerId: BUILT_IN_ANTHROPIC_PROVIDER.id, modelId: 'claude-haiku-4-5-20251001', displayName: 'Haiku 4.5', description: 'Fast & lightweight', tier: 'haiku' },
   { id: 'anthropic-sonnet', providerId: BUILT_IN_ANTHROPIC_PROVIDER.id, modelId: 'claude-sonnet-4-6', displayName: 'Sonnet 4.6', description: 'Balanced', tier: 'sonnet' },
@@ -29,6 +35,15 @@ export const BUILT_IN_OPENAI_MODELS = OPENAI_MODELS.map((model) => ({
   tier: 'custom',
 }));
 
+export const BUILT_IN_GOOGLE_MODELS = GEMINI_MODELS.map((model) => ({
+  id: model.seedId,
+  providerId: BUILT_IN_GOOGLE_PROVIDER.id,
+  modelId: model.id,
+  displayName: model.name,
+  description: model.description,
+  tier: 'custom',
+}));
+
 export const DEFAULT_QUICK_RESPONSES = [
   { label: 'Put a plan on the canvas', content: 'Put a plan on the canvas to get this done', autoSubmit: false, sortOrder: 0 },
   { label: 'Yes', content: 'Yes', autoSubmit: true, sortOrder: 1 },
@@ -87,6 +102,13 @@ function seedBuiltInProviders(db) {
      VALUES (?, ?, ?, ?, ?, ?, ?)`
   );
 
+  // Note: Google provider and models are NOT seeded here because seedBaselineData
+  // runs before migrations. On existing databases the providers table still has
+  // CHECK(kind IN ('anthropic','openai')), so an INSERT with kind='google' would
+  // be silently ignored by INSERT OR IGNORE, and the subsequent model inserts
+  // would fail with a FOREIGN KEY constraint. The 'providers-seed-built-in-google'
+  // migration handles seeding Google for both fresh and existing databases after
+  // the 'providers-widen-kind-check-google' migration has widened the CHECK constraint.
   for (const model of [...BUILT_IN_ANTHROPIC_MODELS, ...BUILT_IN_OPENAI_MODELS]) {
     insertModel.run(model.id, model.providerId, model.modelId, model.displayName, model.description, model.tier, now);
   }

package/packages/server/src/schema.sql

@@ -43,7 +43,7 @@ CREATE TABLE IF NOT EXISTS providers (
   additional_env_vars TEXT,
   commit_attribution_override TEXT,
   is_built_in INTEGER NOT NULL DEFAULT 0,
-  kind TEXT NOT NULL DEFAULT 'anthropic' CHECK(kind IN ('anthropic','openai')),
+  kind TEXT NOT NULL DEFAULT 'anthropic' CHECK(kind IN ('anthropic','openai','google')),
   created_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
   updated_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
 );

package/packages/server/src/services/e2eSpawnCapture.js

@@ -49,9 +49,12 @@ export function createCapturedSpawnProcess(agentType) {
     });
   };
 
-  if (agentType === 'claude-code') {
+  if (agentType === 'claude-code' || agentType === 'gemini') {
+    // Claude Code and Gemini don't pass prompts via stdin (they use CLI args).
+    // Complete after a short delay to simulate process execution.
     setTimeout(complete, 10);
   } else {
+    // Codex passes the prompt via stdin; complete when stdin is closed.
     stdin.once('finish', complete);
   }
 
@@ -59,12 +62,15 @@ export function createCapturedSpawnProcess(agentType) {
 }
 
 function summarizeSpawnEnv(env = {}) {
-  if (!Object.prototype.hasOwnProperty.call(env, 'CIRCUSCHIEF_COMMIT_ATTRIBUTION')) {
-    return {};
+  const summary = {};
+  if (Object.prototype.hasOwnProperty.call(env, 'CIRCUSCHIEF_COMMIT_ATTRIBUTION')) {
+    summary.CIRCUSCHIEF_COMMIT_ATTRIBUTION = env.CIRCUSCHIEF_COMMIT_ATTRIBUTION;
   }
-  return {
-    CIRCUSCHIEF_COMMIT_ATTRIBUTION: env.CIRCUSCHIEF_COMMIT_ATTRIBUTION,
-  };
+  if (Object.prototype.hasOwnProperty.call(env, 'GEMINI_CLI_TRUST_WORKSPACE')) {
+    summary.GEMINI_CLI_TRUST_WORKSPACE = env.GEMINI_CLI_TRUST_WORKSPACE;
+  }
+  if (Object.keys(summary).length === 0) return {};
+  return summary;
 }
 
 function summarizeSpawnOptions(agentType, spawnOptions) {
@@ -78,6 +84,15 @@ function summarizeSpawnOptions(agentType, spawnOptions) {
     };
   }
 
+  if (agentType === 'gemini') {
+    return {
+      model: valueAfter(args, '-m'),
+      outputFormat: valueAfter(args, '--output-format'),
+      approvalMode: optionValue(args, '--approval-mode'),
+      prompt: valueAfter(args, '-p'),
+    };
+  }
+
   return {
     model: valueAfter(args, '-m'),
     sandbox: valueAfter(args, '--sandbox'),
@@ -91,6 +106,14 @@ function valueAfter(args, flag) {
   return args[index + 1] ?? null;
 }
 
+function optionValue(args, flag) {
+  const separateValue = valueAfter(args, flag);
+  if (separateValue !== null) return separateValue;
+  const prefix = `${flag}=`;
+  const arg = args.find((value) => value.startsWith(prefix));
+  return arg ? arg.slice(prefix.length) : null;
+}
+
 function valuesAfter(args, flag) {
   const values = [];
   for (let index = 0; index < args.length; index += 1) {
@@ -116,6 +139,24 @@ function writeCapturedAgentEvents(agentType, stdout) {
     return;
   }
 
+  if (agentType === 'gemini') {
+    // Gemini CLI stream-json format: init → message → result
+    writeJsonLine(stdout, {
+      type: 'init',
+      session_id: `e2e-gemini-${Date.now()}`,
+    });
+    writeJsonLine(stdout, {
+      type: 'message',
+      role: 'assistant',
+      content: 'E2E spawn capture response.',
+    });
+    writeJsonLine(stdout, {
+      type: 'result',
+      stats: { input_tokens: 0, output_tokens: 0 },
+    });
+    return;
+  }
+
   writeJsonLine(stdout, {
     type: 'system',
     subtype: 'init',

package/packages/server/src/services/geminiSpawnHelper.js

@@ -0,0 +1,47 @@
+import { spawn } from 'child_process';
+import { createRobustEnv } from './nodeSpawnHelper.js';
+import {
+  captureSpawnAttempt,
+  createCapturedSpawnProcess,
+  isE2ESpawnCaptureEnabled,
+} from './e2eSpawnCapture.js';
+
+/**
+ * Create a custom spawn function for the Gemini CLI.
+ *
+ * Mirrors {@link createCodexSpawner} but for the `gemini` command.
+ *
+ * As with other CLI helpers:
+ *   - The command 'node' is replaced with {@link process.execPath} so child
+ *     processes use the same Node binary.
+ *   - `createRobustEnv` guarantees the Node bin directory is on PATH.
+ *
+ * @returns {Function} Spawn function of shape (options) => childProcess
+ */
+export function createGeminiSpawner() {
+  return (options) => {
+    const { command, args, cwd, env, signal } = options;
+    // Replace 'node' with the absolute path to the current Node executable
+    const actualCommand = command === 'node' ? process.execPath : command;
+
+    // Ensure PATH includes the directory containing Node
+    const robustEnv = createRobustEnv(env);
+
+    // Trust the workspace automatically in headless/automated mode.
+    // Without this, Gemini CLI refuses to run in untrusted directories.
+    robustEnv.GEMINI_CLI_TRUST_WORKSPACE = 'true';
+
+    if (isE2ESpawnCaptureEnabled()) {
+      captureSpawnAttempt('gemini', { ...options, env: robustEnv });
+      return createCapturedSpawnProcess('gemini');
+    }
+
+    return spawn(actualCommand, args, {
+      cwd,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      signal,
+      env: robustEnv,
+      windowsHide: true,
+    });
+  };
+}

package/packages/server/src/services/gitDiff.js

@@ -6,11 +6,7 @@ import { git } from './gitService.js';
  * @returns {Promise<string>}
  */
 export async function getDiff(directory) {
-  try {
-    return await git(directory, 'diff');
-  } catch {
-    return '';
-  }
+  return git(directory, 'diff');
 }
 
 /**
@@ -19,11 +15,7 @@ export async function getDiff(directory) {
  * @returns {Promise<string>}
  */
 export async function getStagedDiff(directory) {
-  try {
-    return await git(directory, 'diff --cached');
-  } catch {
-    return '';
-  }
+  return git(directory, 'diff --cached');
 }
 
 /**
@@ -36,7 +28,8 @@ export async function getUntrackedFiles(directory) {
     const output = await git(directory, 'ls-files --others --exclude-standard');
     if (!output) return [];
     return output.split('\n').filter((line) => line.trim());
-  } catch {
+  } catch (error) {
+    console.warn(`Failed to get untracked files for ${directory}:`, error.message);
     return [];
   }
 }
@@ -48,11 +41,7 @@ export async function getUntrackedFiles(directory) {
  * @returns {Promise<string>}
  */
 export async function getDiffAgainstBranch(directory, branch) {
-  try {
-    return await git(directory, `diff ${branch}`);
-  } catch {
-    return '';
-  }
+  return git(directory, `diff ${branch}`);
 }
 
 /**
@@ -62,11 +51,7 @@ export async function getDiffAgainstBranch(directory, branch) {
  * @returns {Promise<string>}
  */
 export async function getStagedDiffAgainstBranch(directory, branch) {
-  try {
-    return await git(directory, `diff --cached ${branch}`);
-  } catch {
-    return '';
-  }
+  return git(directory, `diff --cached ${branch}`);
 }
 
 /**
@@ -78,11 +63,16 @@ export async function getStagedDiffAgainstBranch(directory, branch) {
  * @returns {Promise<string>}
  */
 export async function getDiffBetweenRefs(directory, fromRef, toRef) {
-  try {
-    return await git(directory, `diff ${fromRef} ${toRef}`);
-  } catch {
-    return '';
-  }
+  return git(directory, `diff ${fromRef} ${toRef}`);
+}
+
+function addGitPathOutput(files, output) {
+  if (!output) return;
+
+  output.split('\n').forEach((file) => {
+    const trimmed = file.trim();
+    if (trimmed) files.add(trimmed);
+  });
 }
 
 /**
@@ -94,35 +84,20 @@ export async function getDiffBetweenRefs(directory, fromRef, toRef) {
  */
 export async function getModifiedFilesCount(directory, branch) {
   try {
-    // Get all modified files in one command using --name-only
-    // This includes: committed changes vs branch + staged
-    const committedAndStaged = await git(
+    const committed = await git(
       directory,
       `diff --name-only ${branch}...HEAD`
     );
 
-    // Get unstaged changes (working tree vs index)
+    const staged = await git(directory, 'diff --cached --name-only');
     const unstaged = await git(directory, 'diff --name-only');
-
-    // Get untracked files
     const untracked = await getUntrackedFiles(directory);
 
-    // Combine all files into a Set to get unique count
     const allFiles = new Set();
-
-    if (committedAndStaged) {
-      committedAndStaged.split('\n').forEach(f => {
-        if (f.trim()) allFiles.add(f.trim());
-      });
-    }
-
-    if (unstaged) {
-      unstaged.split('\n').forEach(f => {
-        if (f.trim()) allFiles.add(f.trim());
-      });
-    }
-
-    untracked.forEach(f => allFiles.add(f));
+    addGitPathOutput(allFiles, committed);
+    addGitPathOutput(allFiles, staged);
+    addGitPathOutput(allFiles, unstaged);
+    untracked.forEach((file) => allFiles.add(file));
 
     return allFiles.size;
   } catch (error) {

package/packages/server/src/services/gitService.js

@@ -30,6 +30,7 @@ export {
 } from './gitWorktree.js';
 
 const execAsync = promisify(exec);
+export const DEFAULT_GIT_MAX_BUFFER = 100 * 1024 * 1024;
 
 // Cache for default branch detection: directory -> { branch, timestamp }
 const defaultBranchCache = new Map();
@@ -70,10 +71,14 @@ function evictOldestCacheEntries() {
  * @param {Object} [opts]
  * @param {Object} [opts.env]
  * @param {number} [opts.timeout]
+ * @param {number} [opts.maxBuffer]
  * @returns {Promise<string>}
  */
 export async function git(directory, command, opts = {}) {
-  const execOpts = { cwd: directory };
+  const execOpts = {
+    cwd: directory,
+    maxBuffer: opts.maxBuffer ?? DEFAULT_GIT_MAX_BUFFER,
+  };
   if (opts.env) execOpts.env = opts.env;
   if (opts.timeout) execOpts.timeout = opts.timeout;
   const { stdout } = await execAsync(`git ${command}`, execOpts);
@@ -290,4 +295,3 @@ export async function pinAuthorInWorktree(worktreePath, projectDir, { env } = {}
 
   return true;
 }
-

package/packages/server/src/services/providerTestService.js

@@ -1,5 +1,6 @@
 import Anthropic from '@anthropic-ai/sdk';
 import OpenAI from 'openai';
+import { createGeminiSpawner } from './geminiSpawnHelper.js';
 
 /**
  * Test a provider configuration by making a minimal API call.
@@ -22,11 +23,14 @@ import OpenAI from 'openai';
  * @param {number} [config.apiTimeoutMs] - API timeout in milliseconds
  * @returns {Promise<{success: boolean, message: string, details?: Object}>}
  */
-export async function testProviderConnection(config) {
+export async function testProviderConnection(config, deps = {}) {
   const { kind = 'anthropic' } = config || {};
   if (kind === 'openai') {
     return testOpenAIConnection(config);
   }
+  if (kind === 'google') {
+    return testGoogleConnection(config, deps);
+  }
   return testAnthropicConnection(config);
 }
 
@@ -127,6 +131,60 @@ async function testOpenAIChatEndpoint(client, config) {
   });
 }
 
+/**
+ * Google/Gemini connection test. Spawns `gemini -p "Hi" --output-format json`
+ * and checks for a clean exit. No SDK dependency needed.
+ * @private
+ */
+async function testGoogleConnection(config, deps = {}) {
+  try {
+    const env = {};
+    if (config.authToken) env.GEMINI_API_KEY = config.authToken;
+    const timeoutMs = config.apiTimeoutMs || 30000;
+    const spawnGeminiProcess = deps.spawnGeminiProcess || createGeminiSpawner();
+    const child = spawnGeminiProcess({
+      command: 'gemini',
+      args: ['-p', 'Hi', '--output-format', 'json', '--skip-trust', '--approval-mode=auto_edit', '-m', 'gemini-2.5-flash'],
+      cwd: config.workingDirectory,
+      env,
+    });
+
+    return await new Promise((resolve) => {
+      let stderr = '';
+      let killed = false;
+
+      const timer = setTimeout(() => {
+        killed = true;
+        try { child.kill('SIGTERM'); } catch { /* ignore */ }
+        resolve(failureResponse(new Error(`Gemini CLI timed out after ${timeoutMs}ms`)));
+      }, timeoutMs);
+
+      child.stdout?.on('data', () => { /* drain */ });
+      child.stderr?.on('data', (d) => { stderr += d; });
+      child.on('error', (error) => {
+        clearTimeout(timer);
+        if (killed) return;
+        if (error.code === 'ENOENT') {
+          resolve(failureResponse(new Error('Gemini CLI not found. Install via: npm install -g @google/gemini-cli')));
+        } else {
+          resolve(failureResponse(error));
+        }
+      });
+      child.on('exit', (code) => {
+        clearTimeout(timer);
+        if (killed) return;
+        if (code === 0) {
+          resolve(connectionSuccess({ model: 'gemini-2.5-flash' }));
+        } else {
+          resolve(failureResponse(new Error(stderr.trim() || `Gemini CLI exited with code ${code}`)));
+        }
+      });
+    });
+  } catch (error) {
+    return failureResponse(error);
+  }
+}
+
 function connectionSuccess(details) {
   return {
     success: true,

package/packages/server/src/services/queryParamBuilder.js

@@ -1,6 +1,7 @@
 import { createClaudeCodeSpawner } from './nodeSpawnHelper.js';
 import {
   buildSystemPromptConfig,
+  getGeminiApprovalModeForSession,
   getPermissionModeForSession,
   getSandboxModeForSession,
 } from './sessionPrompts.js';
@@ -64,6 +65,34 @@ function buildCodexQueryParams({
   };
 }
 
+/**
+ * Build query parameters for the Gemini adapter.
+ *
+ * Gemini CLI is prompt-driven via `-p` flag. It does not need Claude-specific
+ * options (permissionMode, settingSources, resume) or Codex-specific options
+ * (sandboxMode, effortLevel).
+ *
+ * @returns {Object}
+ */
+function buildGeminiQueryParams({
+  prompt, workingDirectory, controller, session, sessionId, systemPrompt, model, sessionEnv,
+}) {
+  const isVCR = Boolean(process.env.VCR_MODE);
+  const effectiveModel = isVCR ? 'gemini-2.5-flash' : model;
+
+  return {
+    prompt,
+    options: {
+      cwd: workingDirectory,
+      abortController: controller,
+      env: sessionEnv,
+      model: effectiveModel,
+      approvalMode: getGeminiApprovalModeForSession(session?.mode),
+      systemPrompt: buildSystemPromptConfig(sessionId, session.projectId, systemPrompt, session.mode),
+    },
+  };
+}
+
 /**
  * Build query parameters for executing a session via the configured agent.
  * Shared by runSession, continueSession, and continueSessionWithExistingMessage.
@@ -78,7 +107,7 @@ function buildCodexQueryParams({
  * @param {string|null} options.model - Model to use
  * @param {Object} options.sessionEnv - Environment variables for the session
  * @param {string|null} [options.resumeSessionId] - Session ID to resume (null for new session)
- * @param {string} [options.agentType] - 'claude-code' (default) | 'codex'
+ * @param {string} [options.agentType] - 'claude-code' (default) | 'codex' | 'gemini'
  * @returns {Object} Query parameters for agent.execute()
  */
 export function buildQueryParams(options) {
@@ -86,5 +115,8 @@ export function buildQueryParams(options) {
   if (agentType === 'codex') {
     return buildCodexQueryParams(options);
   }
+  if (agentType === 'gemini') {
+    return buildGeminiQueryParams(options);
+  }
   return buildClaudeCodeQueryParams(options);
 }

package/packages/server/src/services/sessionExecution.js

@@ -1,5 +1,6 @@
 import { sessions, messages, attachments, conversations } from '../database.js';
 import { createCodexSpawner } from './codexSpawnHelper.js';
+import { createGeminiSpawner } from './geminiSpawnHelper.js';
 import { resolveProviderFromModel, resolveProviderMetadataFromModel, buildSessionEnv } from './sessionProvider.js';
 import { agentGateway } from '../agents/AgentGateway.js';
 import { LoggingAgentWrapper } from '../agents/LoggingAgentWrapper.js';
@@ -37,6 +38,9 @@ function buildAgentConfig(agentType) {
   if (agentType === 'codex') {
     return { spawnCodexProcess: createCodexSpawner() };
   }
+  if (agentType === 'gemini') {
+    return { spawnGeminiProcess: createGeminiSpawner() };
+  }
   return {};
 }
 

package/packages/server/src/services/sessionPrompts.js

@@ -134,6 +134,28 @@ export function getSandboxModeForSession(mode) {
   }
 }
 
+/**
+ * Map session mode to Gemini CLI --approval-mode.
+ *
+ *   plan     -> plan
+ *   standard -> auto_edit
+ *   yolo     -> yolo
+ *
+ * @param {string} mode - Session mode ('plan', 'standard', 'yolo')
+ * @returns {string} Gemini CLI approval mode
+ */
+export function getGeminiApprovalModeForSession(mode) {
+  switch (mode) {
+    case 'plan':
+      return 'plan';
+    case 'yolo':
+      return 'yolo';
+    case 'standard':
+    default:
+      return 'auto_edit';
+  }
+}
+
 /** Plan mode system prompt instructions */
 export const PLAN_MODE_PROMPT = `## Plan Mode Active