claude-simple 0.2.8 → 0.2.10

package/src/agents/grok.js

@@ -1,10 +1,11 @@
 import { spawn } from 'child_process';
+import fs from 'fs';
+import path from 'path';
 import readline from 'readline';
 import crypto from 'crypto';
 
-// Grok's ACP transport is a long-lived JSON-RPC process.  Keeping it alive is
-// important: it owns the real Grok session and lets the edge, rather than an
-// individual browser tab, serialize follow-up prompts.
+// Persistent ACP (JSON-RPC over stdio). Advertise terminal+fs so Grok routes
+// shell/file tools through client RPCs instead of its own broken terminal path.
 const clients = new Map();
 const queues = new Map();
 const queueAliases = new Map();
@@ -13,6 +14,147 @@ function profileKey(options) {
   return `${options.model || ''}\u001f${options.effort || ''}`;
 }
 
+function envFromParams(envList) {
+  const env = { ...process.env };
+  if (!Array.isArray(envList)) return env;
+  for (const item of envList) {
+    if (!item || typeof item.name !== 'string') continue;
+    env[item.name] = item.value == null ? '' : String(item.value);
+  }
+  return env;
+}
+
+class TerminalHost {
+  constructor() {
+    this.terminals = new Map();
+  }
+
+  create(params = {}) {
+    const terminalId = `term_${crypto.randomUUID()}`;
+    const command = String(params.command || '');
+    const args = Array.isArray(params.args) ? params.args.map(String) : [];
+    const cwd = params.cwd || process.cwd();
+    const limit = Number.isFinite(params.outputByteLimit) && params.outputByteLimit > 0
+      ? params.outputByteLimit
+      : 1024 * 1024;
+    const env = envFromParams(params.env);
+
+    let child;
+    try {
+      child = spawn(command, args, {
+        cwd,
+        env,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        shell: args.length === 0,
+      });
+    } catch (error) {
+      const err = new Error(error.message || 'Failed to start terminal');
+      err.code = -32000;
+      throw err;
+    }
+
+    const entry = {
+      id: terminalId,
+      child,
+      output: '',
+      truncated: false,
+      limit,
+      exitCode: null,
+      signal: null,
+      exited: false,
+      waiters: [],
+    };
+
+    const append = chunk => {
+      entry.output += chunk;
+      if (Buffer.byteLength(entry.output, 'utf8') > entry.limit) {
+        // Truncate from the start at a UTF-8-safe boundary.
+        let buf = Buffer.from(entry.output, 'utf8');
+        buf = buf.subarray(buf.length - entry.limit);
+        while (buf.length && (buf[0] & 0xc0) === 0x80) buf = buf.subarray(1);
+        entry.output = buf.toString('utf8');
+        entry.truncated = true;
+      }
+    };
+
+    child.stdout?.setEncoding('utf8');
+    child.stderr?.setEncoding('utf8');
+    child.stdout?.on('data', append);
+    child.stderr?.on('data', append);
+    child.on('error', err => {
+      append(`\n[terminal error] ${err.message}\n`);
+      if (!entry.exited) {
+        entry.exited = true;
+        entry.exitCode = 1;
+        entry.signal = null;
+        for (const resolve of entry.waiters) resolve({ exitCode: 1, signal: null });
+        entry.waiters = [];
+      }
+    });
+    child.on('close', (code, signal) => {
+      entry.exited = true;
+      entry.exitCode = code;
+      entry.signal = signal || null;
+      for (const resolve of entry.waiters) resolve({ exitCode: code, signal: signal || null });
+      entry.waiters = [];
+    });
+
+    this.terminals.set(terminalId, entry);
+    return { terminalId };
+  }
+
+  get(terminalId) {
+    const entry = this.terminals.get(terminalId);
+    if (!entry) {
+      const err = new Error(`Unknown terminal: ${terminalId}`);
+      err.code = -32000;
+      throw err;
+    }
+    return entry;
+  }
+
+  output(terminalId) {
+    const entry = this.get(terminalId);
+    const result = {
+      output: entry.output,
+      truncated: entry.truncated,
+    };
+    if (entry.exited) {
+      result.exitStatus = { exitCode: entry.exitCode, signal: entry.signal };
+    }
+    return result;
+  }
+
+  waitForExit(terminalId) {
+    const entry = this.get(terminalId);
+    if (entry.exited) return Promise.resolve({ exitCode: entry.exitCode, signal: entry.signal });
+    return new Promise(resolve => entry.waiters.push(resolve));
+  }
+
+  kill(terminalId) {
+    const entry = this.get(terminalId);
+    if (!entry.exited && entry.child?.pid) {
+      try { entry.child.kill('SIGTERM'); } catch { /* already gone */ }
+    }
+    return {};
+  }
+
+  release(terminalId) {
+    const entry = this.terminals.get(terminalId);
+    if (!entry) return {};
+    if (!entry.exited && entry.child?.pid) {
+      try { entry.child.kill('SIGTERM'); } catch { /* already gone */ }
+      setTimeout(() => {
+        if (!entry.exited && entry.child?.pid) {
+          try { entry.child.kill('SIGKILL'); } catch { /* already gone */ }
+        }
+      }, 800).unref?.();
+    }
+    this.terminals.delete(terminalId);
+    return {};
+  }
+}
+
 class GrokACPClient {
   constructor({ cliPath, model, effort }) {
     const args = ['agent', '--always-approve'];
@@ -22,13 +164,17 @@ class GrokACPClient {
     this.child = spawn(cliPath || 'grok', args, { stdio: ['pipe', 'pipe', 'pipe'] });
     this.pending = new Map();
     this.listeners = new Map();
-    this.nextID = 1;
+    // High ids avoid colliding with agent-originated request ids (often 0..N).
+    this.nextID = 100000;
+    this.terminals = new TerminalHost();
     this.ready = this.initialize();
     this.child.stderr.on('data', d => console.warn(`[grok acp] ${String(d).trim()}`));
     this.child.on('close', () => {
       for (const { reject } of this.pending.values()) reject(new Error('Grok ACP process stopped'));
       this.pending.clear();
-      for (const fn of this.listeners.values()) fn({ type: 'error', message: 'Grok ACP process stopped', agent: 'grok' });
+      for (const fn of this.listeners.values()) {
+        fn({ type: 'error', message: 'Grok ACP process stopped', agent: 'grok' });
+      }
       this.listeners.clear();
     });
     const rl = readline.createInterface({ input: this.child.stdout, crlfDelay: Infinity });
@@ -38,19 +184,82 @@ class GrokACPClient {
   async initialize() {
     const init = await this.request('initialize', {
       protocolVersion: 1,
-      clientCapabilities: { fs: { readTextFile: true, writeTextFile: true }, terminal: true },
-      clientInfo: { name: 'claude-simple-ui', version: '0.2.7' },
+      clientCapabilities: {
+        fs: { readTextFile: true, writeTextFile: true },
+        terminal: true,
+      },
+      clientInfo: { name: 'claude-simple-ui', version: '0.2.9' },
     });
     const methods = new Set((init.authMethods || []).map(x => x?.id));
     const methodId = process.env.XAI_API_KEY && methods.has('xai.api_key')
       ? 'xai.api_key'
       : (methods.has('cached_token') ? 'cached_token' : null);
     if (methodId) await this.request('authenticate', { methodId, _meta: { headless: true } });
+    return init;
+  }
+
+  async handleClientRequest(msg) {
+    const method = msg.method;
+    const params = msg.params || {};
+    try {
+      let result = {};
+      if (method === 'fs/read_text_file') {
+        const filePath = String(params.path || '');
+        const content = await fs.promises.readFile(filePath, 'utf8');
+        const limit = Number.isFinite(params.limit) ? params.limit : null;
+        const line = Number.isFinite(params.line) ? params.line : null;
+        if (line != null || limit != null) {
+          const lines = content.split('\n');
+          const start = Math.max(0, (line || 1) - 1);
+          const end = limit != null ? start + limit : lines.length;
+          result = { content: lines.slice(start, end).join('\n') };
+        } else {
+          result = { content };
+        }
+      } else if (method === 'fs/write_text_file') {
+        const filePath = String(params.path || '');
+        await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
+        await fs.promises.writeFile(filePath, params.content ?? '', 'utf8');
+        result = {};
+      } else if (method === 'terminal/create') {
+        result = this.terminals.create(params);
+      } else if (method === 'terminal/output') {
+        result = this.terminals.output(params.terminalId);
+      } else if (method === 'terminal/wait_for_exit') {
+        result = await this.terminals.waitForExit(params.terminalId);
+      } else if (method === 'terminal/kill') {
+        result = this.terminals.kill(params.terminalId);
+      } else if (method === 'terminal/release') {
+        result = this.terminals.release(params.terminalId);
+      } else {
+        this.write({
+          jsonrpc: '2.0',
+          id: msg.id,
+          error: { code: -32601, message: `Unsupported client method: ${method}` },
+        });
+        return;
+      }
+      this.write({ jsonrpc: '2.0', id: msg.id, result });
+    } catch (error) {
+      this.write({
+        jsonrpc: '2.0',
+        id: msg.id,
+        error: { code: error.code || -32000, message: error.message || 'Client request failed' },
+      });
+    }
   }
 
   receive(line) {
     let msg;
     try { msg = JSON.parse(line); } catch { return; }
+
+    // Agent→client requests always carry a method. Check before pending so
+    // overlapping numeric ids cannot steal a client RPC as our response.
+    if (msg.id != null && msg.method) {
+      void this.handleClientRequest(msg);
+      return;
+    }
+
     if (msg.id != null && this.pending.has(msg.id)) {
       const pending = this.pending.get(msg.id);
       this.pending.delete(msg.id);
@@ -58,13 +267,7 @@ class GrokACPClient {
       else pending.resolve(msg.result || {});
       return;
     }
-    // Grok's documented ACP client sample does not need client-side tool RPC.
-    // Return a structured error for optional extension calls instead of leaving
-    // an agent request hanging forever.
-    if (msg.id != null && msg.method) {
-      this.write({ jsonrpc: '2.0', id: msg.id, error: { code: -32601, message: `Unsupported client method: ${msg.method}` } });
-      return;
-    }
+
     if (msg.method === 'session/update') {
       const sid = msg.params?.sessionId;
       const fn = sid && this.listeners.get(sid);
@@ -109,37 +312,68 @@ class GrokACPClient {
 function clientFor(options, cliPath) {
   const key = profileKey(options);
   let client = clients.get(key);
-  if (!client || client.child.exitCode != null) {
+  if (!client || client.child.exitCode != null || client.child.signalCode != null) {
     client = new GrokACPClient({ cliPath, model: options.model, effort: options.effort });
     clients.set(key, client);
   }
   return client;
 }
 
-function emitUpdate(update, send, sessionId, state) {
+function emitUpdate(update, send, state) {
   const kind = update?.sessionUpdate;
   if (kind === 'agent_message_chunk' && update.content?.text) {
-    if (!state.textOpen) { send({ type: 'assistant_stream_start', agent: 'grok', ts: Date.now() }); state.textOpen = true; }
+    if (state.thoughtOpen) {
+      send({ type: 'thought_stream_end', agent: 'grok' });
+      state.thoughtOpen = false;
+    }
+    if (!state.textOpen) {
+      send({ type: 'assistant_stream_start', agent: 'grok', ts: Date.now() });
+      state.textOpen = true;
+    }
     send({ type: 'assistant_delta', data: update.content.text, agent: 'grok' });
   } else if (kind === 'agent_thought_chunk' && update.content?.text) {
-    if (!state.thoughtOpen) { send({ type: 'thought_stream_start', agent: 'grok' }); state.thoughtOpen = true; }
+    if (!state.thoughtOpen) {
+      send({ type: 'thought_stream_start', agent: 'grok' });
+      state.thoughtOpen = true;
+    }
     send({ type: 'thought_delta', data: update.content.text, agent: 'grok' });
   } else if (kind === 'tool_call' || kind === 'tool_call_update') {
-    if (state.textOpen) { send({ type: 'assistant_stream_end', agent: 'grok' }); state.textOpen = false; }
-    if (state.thoughtOpen) { send({ type: 'thought_stream_end', agent: 'grok' }); state.thoughtOpen = false; }
+    if (state.textOpen) {
+      send({ type: 'assistant_stream_end', agent: 'grok' });
+      state.textOpen = false;
+    }
+    if (state.thoughtOpen) {
+      send({ type: 'thought_stream_end', agent: 'grok' });
+      state.thoughtOpen = false;
+    }
     if (kind === 'tool_call') {
-      send({ type: 'assistant', agent: 'grok', message: { content: [{
-        type: 'tool_use', name: update.title || update.kind || 'tool', input: update.rawInput || update.input || {},
-      }] } });
+      send({
+        type: 'assistant',
+        agent: 'grok',
+        message: {
+          content: [{
+            type: 'tool_use',
+            name: update.title || update.kind || 'tool',
+            input: update.rawInput || update.input || {},
+          }],
+        },
+      });
     }
   }
 }
 
 async function runOne(item, { cliPath, activeSessions, queueKey }) {
   const { command, options, send } = item;
-  const client = clientFor(options, cliPath);
+  const effort = options.effort || 'low';
+  const client = clientFor({ ...options, effort }, cliPath);
   const localKey = options.sessionId || crypto.randomUUID();
-  const entry = { kind: 'grok-acp', startTime: Date.now(), busy: true, key: localKey, sessionId: options.sessionId || null };
+  const entry = {
+    kind: 'grok-acp',
+    startTime: Date.now(),
+    busy: true,
+    key: localKey,
+    sessionId: options.sessionId || null,
+  };
   activeSessions.set(localKey, entry);
   const state = { textOpen: false, thoughtOpen: false };
   let sessionId = options.sessionId;
@@ -148,9 +382,14 @@ async function runOne(item, { cliPath, activeSessions, queueKey }) {
     queueAliases.set(sessionId, queueKey);
     entry.sessionId = sessionId;
     activeSessions.set(sessionId, entry);
-    entry.abort = () => { client.write({ jsonrpc: '2.0', method: 'session/cancel', params: { sessionId } }); };
+    entry.abort = () => {
+      try {
+        client.write({ jsonrpc: '2.0', method: 'session/cancel', params: { sessionId } });
+      } catch { /* process may already be gone */ }
+    };
     if (!options.sessionId) send({ type: 'session-created', sessionId, agent: 'grok' });
-    client.listeners.set(sessionId, update => emitUpdate(update, send, sessionId, state));
+    client.listeners.set(sessionId, update => emitUpdate(update, send, state));
+    send({ type: 'status', message: 'Grok ACP running…', agent: 'grok', sessionId });
     const result = await client.request('session/prompt', {
       sessionId,
       prompt: [{ type: 'text', text: command }],
@@ -158,10 +397,24 @@ async function runOne(item, { cliPath, activeSessions, queueKey }) {
     if (state.textOpen) send({ type: 'assistant_stream_end', agent: 'grok' });
     if (state.thoughtOpen) send({ type: 'thought_stream_end', agent: 'grok' });
     entry.busy = false;
-    send({ type: 'result', is_error: result.stopReason === 'error', usage: result._meta?.usage || null, sessionId, agent: 'grok' });
-    send({ type: 'complete', exitCode: result.stopReason === 'cancelled' ? 130 : 0, aborted: result.stopReason === 'cancelled', sessionId, agent: 'grok' });
+    send({
+      type: 'result',
+      is_error: result.stopReason === 'error',
+      usage: result._meta?.usage || null,
+      sessionId,
+      agent: 'grok',
+    });
+    send({
+      type: 'complete',
+      exitCode: result.stopReason === 'cancelled' ? 130 : 0,
+      aborted: result.stopReason === 'cancelled',
+      sessionId,
+      agent: 'grok',
+    });
   } catch (e) {
     entry.busy = false;
+    if (state.textOpen) send({ type: 'assistant_stream_end', agent: 'grok' });
+    if (state.thoughtOpen) send({ type: 'thought_stream_end', agent: 'grok' });
     send({ type: 'error', message: e.message, sessionId, agent: 'grok' });
     send({ type: 'complete', exitCode: 1, sessionId, agent: 'grok' });
   } finally {
@@ -171,19 +424,26 @@ async function runOne(item, { cliPath, activeSessions, queueKey }) {
   }
 }
 
-/** Queue all Grok follow-ups at the edge. The promise resolves after this item runs. */
+/** Queue all Grok follow-ups at the edge. Promise resolves after this item runs. */
 export function runGrok(command, options, send, { cliPath, activeSessions }) {
-  const key = (options.sessionId && queueAliases.get(options.sessionId)) || options.sessionId || `new:${options.cwd || ''}`;
+  const key = (options.sessionId && queueAliases.get(options.sessionId))
+    || options.sessionId
+    || `new:${options.cwd || ''}`;
   const queue = queues.get(key) || { items: [], running: false };
   queues.set(key, queue);
   return new Promise(resolve => {
     queue.items.push({ command, options, send, resolve });
     if (queue.running) {
-      send({ type: 'status', message: `Grok follow-up queued (${queue.items.length - 1} ahead)`, sessionId: options.sessionId, agent: 'grok' });
+      send({
+        type: 'status',
+        message: `Grok follow-up queued (${queue.items.length - 1} ahead)`,
+        sessionId: options.sessionId,
+        agent: 'grok',
+      });
       return;
     }
     queue.running = true;
-    const drain = async () => {
+    void (async () => {
       while (queue.items.length) {
         const item = queue.items.shift();
         await runOne(item, { cliPath, activeSessions, queueKey: key });
@@ -192,16 +452,19 @@ export function runGrok(command, options, send, { cliPath, activeSessions }) {
       queue.running = false;
       queues.delete(key);
       for (const [sid, alias] of queueAliases) if (alias === key) queueAliases.delete(sid);
-    };
-    void drain();
+    })();
   });
 }
 
 export async function interruptGrok(sessionId) {
   for (const client of clients.values()) {
     if (client.listeners.has(sessionId)) {
-      client.write({ jsonrpc: '2.0', method: 'session/cancel', params: { sessionId } });
-      return true;
+      try {
+        client.write({ jsonrpc: '2.0', method: 'session/cancel', params: { sessionId } });
+        return true;
+      } catch {
+        return false;
+      }
     }
   }
   return false;

package/src/agents/meta-agent.js

@@ -38,7 +38,7 @@ export const AI_DEFAULTS = {
   auto_report_days: 1,
 };
 
-export const DEFAULT_SYSTEM = `你是 Claude Simple UI 的内置工作助手（Meta Agent）。你能访问本机上的 Claude / Codex / Grok 会话、项目笔记、Git 与文件，并生成「我做了啥」的工作报告。
+export const DEFAULT_SYSTEM = `你是 Claude Simple UI 的内置工作助手（Meta Agent）。你能访问本机上的 Claude / Codex / Grok / Gemini 会话、项目笔记、Git 与文件，并生成「我做了啥」的工作报告。
 
 规则：
 1. 需要会话 id / 项目路径时，先 list_projects 或 search_activity / list_sessions，再深入 get_session_brief / get_session_summary。超长会话先读 get_session_brief；只有需要逐事件定位问题时才读 get_session_jsonl。
@@ -73,12 +73,12 @@ const TOOLS = [
     type: 'function',
     function: {
       name: 'list_sessions',
-      description: '列出最近 agent 会话（Claude/Codex/Grok）元数据',
+      description: '列出最近 agent 会话（Claude/Codex/Grok/Gemini）元数据',
       parameters: {
         type: 'object',
         properties: {
           days: { type: 'integer', description: '只看最近 N 天，0=全部，默认 14' },
-          agent: { type: 'string', enum: ['claude', 'codex', 'grok'], description: '可选过滤' },
+          agent: { type: 'string', enum: ['claude', 'codex', 'grok', 'gemini', 'cursor'], description: '可选过滤' },
           cwd: { type: 'string', description: '按工作目录过滤' },
           limit: { type: 'integer', description: '最多返回条数，默认 40' },
         },
@@ -153,13 +153,13 @@ const TOOLS = [
     type: 'function',
     function: {
       name: 'get_session_jsonl',
-      description: '读取 Claude/Codex/Grok 指定会话的原始 JSONL 行，用于逐事件、工具调用或失败原因分析；内容可能敏感，只在当前回答中使用',
+      description: '读取 Claude/Codex/Grok/Gemini 指定会话的原始 JSONL 行，用于逐事件、工具调用或失败原因分析；内容可能敏感，只在当前回答中使用',
       parameters: {
         type: 'object',
         required: ['sessionId'],
         properties: {
           sessionId: { type: 'string' },
-          agent: { type: 'string', enum: ['claude', 'codex', 'grok'], description: '建议明确指定来源 agent' },
+          agent: { type: 'string', enum: ['claude', 'codex', 'grok', 'gemini', 'cursor'], description: '建议明确指定来源 agent' },
           offset: { type: 'integer', description: '从第几行开始，默认 0' },
           maxLines: { type: 'integer', description: '每次最多 2000 行，默认 500' },
         },
@@ -500,6 +500,8 @@ export function createMetaAgent(deps) {
     claudeConfigDirs,
     codexHome,
     grokHome,
+    geminiHome,
+    cursorHome,
   } = deps;
 
   const configFile = path.join(rootDir, '.ai_config.json');
@@ -1508,6 +1510,8 @@ export function createMetaAgent(deps) {
       claudeConfigDirs: claudeConfigDirs(),
       codexHome: codexHome(),
       grokHome: grokHome(),
+      geminiHome: geminiHome(),
+      cursorHome: cursorHome(),
     };
   }
 

package/src/agents/models.js

@@ -5,6 +5,7 @@
 import { promises as fs } from 'fs';
 import path from 'path';
 import os from 'os';
+import { execFile } from 'child_process';
 
 /** Static fallbacks when local cache/config is missing. */
 export const FALLBACK_MODELS = {
@@ -37,6 +38,31 @@ export const FALLBACK_MODELS = {
       { value: 'grok-3-mini', label: 'grok-3-mini' },
     ],
   },
+  gemini: {
+    model: 'gemini-3.7-flash-high',
+    models: [
+      { value: 'gemini-3.7-flash-high', label: 'Gemini 3.7 Flash (High)' },
+      { value: 'gemini-3.7-flash-medium', label: 'Gemini 3.7 Flash (Medium)' },
+      { value: 'gemini-3.7-flash-low', label: 'Gemini 3.7 Flash (Low)' },
+      { value: 'gemini-3.6-flash-high', label: 'Gemini 3.6 Flash (High)' },
+      { value: 'gemini-3.6-flash-medium', label: 'Gemini 3.6 Flash (Medium)' },
+      { value: 'gemini-3.6-flash-low', label: 'Gemini 3.6 Flash (Low)' },
+      { value: 'gemini-3.5-flash-high', label: 'Gemini 3.5 Flash (High)' },
+      { value: 'gemini-3.5-flash-medium', label: 'Gemini 3.5 Flash (Medium)' },
+      { value: 'gemini-3.5-flash-low', label: 'Gemini 3.5 Flash (Low)' },
+      { value: 'gemini-3.1-pro-high', label: 'Gemini 3.1 Pro (High)' },
+      { value: 'gemini-3.1-pro-low', label: 'Gemini 3.1 Pro (Low)' },
+    ],
+  },
+  cursor: {
+    model: 'auto',
+    models: [
+      { value: 'auto', label: 'Auto' },
+      { value: 'gpt-5.3-codex', label: 'GPT-5.3 Codex' },
+      { value: 'composer-2.5', label: 'Composer 2.5' },
+      { value: 'claude-sonnet-5-thinking-high', label: 'Claude Sonnet 5' },
+    ],
+  },
 };
 
 const DEFAULT_EFFORTS = ['low', 'medium', 'high', 'xhigh', 'max'];
@@ -304,7 +330,8 @@ async function discoverGrok(grokHome) {
 
   const active = models.find(m => m.value === defaultModel);
   const efforts = active?.efforts || DEFAULT_EFFORTS;
-  const effortDefault = active?.defaultEffort || tomlSectionString(cfgText, 'models', 'default_reasoning_effort') || null;
+  // This UI defaults Grok reasoning effort to low.
+  const effortDefault = 'low';
 
   return {
     model: defaultModel,
@@ -317,11 +344,89 @@ async function discoverGrok(grokHome) {
   };
 }
 
+let geminiModelsCache = null;
+let geminiModelsCachedAt = 0;
+
+async function listAgyModels(cliPath) {
+  if (geminiModelsCache && Date.now() - geminiModelsCachedAt < 60_000) return geminiModelsCache;
+  // agy renders its model picker through a TTY. `script` supplies a tiny
+  // pseudo-terminal while keeping this request non-interactive.
+  const command = cliPath || 'agy';
+  const scriptArgs = process.platform === 'darwin'
+    ? ['-q', '/dev/null', command, 'models']
+    : ['-q', '-c', `${command} models`, '/dev/null'];
+  const output = await new Promise(resolve => {
+    execFile('script', scriptArgs, { timeout: 20_000, maxBuffer: 512 * 1024 }, (error, stdout) => {
+      resolve(error ? '' : String(stdout || ''));
+    });
+  });
+  const models = output.split(/\r?\n/)
+    .map(line => line.replace(/\x1b\[[0-?]*[ -\/]*[@-~]/g, '').trim())
+    .filter(line => /^gemini-/i.test(line))
+    .map(line => {
+      const [value, ...label] = line.split(/\t+/);
+      return { value: value.trim(), label: label.join(' ').trim() || shortLabel(value.trim()) };
+    });
+  geminiModelsCache = uniqModels(models);
+  geminiModelsCachedAt = Date.now();
+  return geminiModelsCache;
+}
+
+async function discoverGemini(geminiHome, cliPath) {
+  const home = geminiHome || path.join(os.homedir(), '.gemini');
+  const settings = await readJson(path.join(home, 'antigravity-cli', 'settings.json'))
+    || await readJson(path.join(home, 'settings.json'));
+  let models = await listAgyModels(cliPath);
+  let source = models.length ? 'agy' : 'fallback';
+  if (!models.length) models = FALLBACK_MODELS.gemini.models.map(m => ({ ...m }));
+  const configured = typeof settings?.model === 'string' ? settings.model.trim() : null;
+  const selected = configured && models.find(m => m.value === configured || m.label === configured);
+  const defaultModel = selected?.value || models[0]?.value || FALLBACK_MODELS.gemini.model;
+  if (configured) source += '+settings';
+  return {
+    model: defaultModel,
+    models: uniqModels(ensureDefaultInList(models, defaultModel)),
+    efforts: ['low', 'medium', 'high'],
+    effortDefault: defaultModel.match(/-(low|medium|high)$/i)?.[1] || null,
+    source,
+  };
+}
+
+let cursorModelsCache = null;
+let cursorModelsCachedAt = 0;
+
+async function listCursorModels(cliPath) {
+  if (cursorModelsCache && Date.now() - cursorModelsCachedAt < 60_000) return cursorModelsCache;
+  const output = await new Promise(resolve => {
+    execFile(cliPath || 'cursor-agent', ['--list-models'], { timeout: 20_000, maxBuffer: 1024 * 1024 }, (error, stdout) => {
+      resolve(error ? '' : String(stdout || ''));
+    });
+  });
+  const models = output.split(/\r?\n/)
+    .map(line => line.trim())
+    .map(line => {
+      const m = /^([^\s]+)\s+-\s+(.+)$/.exec(line);
+      return m ? { value: m[1], label: m[2] } : null;
+    })
+    .filter(Boolean);
+  cursorModelsCache = uniqModels(models);
+  cursorModelsCachedAt = Date.now();
+  return cursorModelsCache;
+}
+
+async function discoverCursor(cursorHome, cliPath) {
+  let models = await listCursorModels(cliPath);
+  const source = models.length ? 'cursor-agent' : 'fallback';
+  if (!models.length) models = FALLBACK_MODELS.cursor.models.map(m => ({ ...m }));
+  const defaultModel = models.find(m => m.value === 'auto')?.value || models[0]?.value || FALLBACK_MODELS.cursor.model;
+  return { model: defaultModel, models: uniqModels(ensureDefaultInList(models, defaultModel)), efforts: [], source };
+}
+
 /**
- * @param {{ claudeConfigDirs?: string[], codexHome?: string, grokHome?: string, agents?: string[] }} opts
+ * @param {{ claudeConfigDirs?: string[], codexHome?: string, grokHome?: string, geminiHome?: string, geminiCliPath?: string, cursorHome?: string, cursorAgentPath?: string, agents?: string[] }} opts
  */
 export async function discoverAllAgentModels(opts = {}) {
-  const agents = opts.agents?.length ? opts.agents : ['claude', 'codex', 'grok'];
+  const agents = opts.agents?.length ? opts.agents : ['claude', 'codex', 'grok', 'gemini', 'cursor'];
   const want = new Set(agents);
   const defaults = {};
 
@@ -334,6 +439,12 @@ export async function discoverAllAgentModels(opts = {}) {
   if (want.has('grok')) {
     defaults.grok = await discoverGrok(opts.grokHome);
   }
+  if (want.has('gemini')) {
+    defaults.gemini = await discoverGemini(opts.geminiHome, opts.geminiCliPath);
+  }
+  if (want.has('cursor')) {
+    defaults.cursor = await discoverCursor(opts.cursorHome, opts.cursorAgentPath);
+  }
 
   return defaults;
 }