claude-simple 0.2.9 → 0.2.11

package/src/agents/cursor.js

@@ -0,0 +1,189 @@
+import { spawn } from 'child_process';
+import { promises as fs } from 'fs';
+import path from 'path';
+import readline from 'readline';
+import crypto from 'crypto';
+
+// Cursor Agent owns its native transcript format.  Keep a small UI journal so
+// sessions started here remain searchable/readable without relying on that
+// private format.
+function journalPath(cursorHome, sessionId) {
+  return path.join(cursorHome, 'claude-simple-ui', 'sessions', `${sessionId}.jsonl`);
+}
+
+function journal(cursorHome, sessionId, value) {
+  if (!sessionId) return;
+  const file = journalPath(cursorHome, sessionId);
+  fs.mkdir(path.dirname(file), { recursive: true })
+    .then(() => fs.appendFile(file, `${JSON.stringify(value)}\n`, 'utf8'))
+    .catch(() => {});
+}
+
+function buildArgs(command, options) {
+  const args = ['--print', '--output-format', 'stream-json', '--stream-partial-output'];
+  if (options.sessionId) args.push('--resume', options.sessionId);
+  if (options.model) args.push('--model', options.model);
+  if (options.cwd) args.push('--workspace', options.cwd);
+  if (options.permissionMode === 'plan') args.push('--mode', 'plan');
+  else if (options.permissionMode === 'ask') args.push('--mode', 'ask');
+  else if (options.allowDangerouslySkipPermissions || ['bypassPermissions', 'acceptEdits', 'auto'].includes(options.permissionMode)) args.push('--force');
+  // The UI has already selected the project directory; do not trigger Cursor's
+  // interactive trust prompt in a non-interactive child process.
+  args.push('--trust', command || '');
+  return args;
+}
+
+function textBlocks(message) {
+  const content = message?.content;
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return '';
+  return content.filter(b => b?.type === 'text' && b.text).map(b => b.text).join('\n');
+}
+
+function toolBlocks(message) {
+  return Array.isArray(message?.content)
+    ? message.content.filter(b => b?.type === 'tool_use' || b?.type === 'tool-call')
+    : [];
+}
+
+/** Run one Cursor Agent turn in headless stream-json mode. */
+export function runCursor(command, options, send, { cliPath, cursorHome, activeSessions }) {
+  return new Promise(resolve => {
+    const sessionKey = options.sessionId || crypto.randomUUID();
+    const home = cursorHome || path.join(process.env.HOME || '', '.cursor');
+    const args = buildArgs(command, options);
+    let child;
+    try {
+      child = spawn(cliPath || 'cursor-agent', args, {
+        cwd: options.cwd || process.cwd(), env: { ...process.env }, stdio: ['ignore', 'pipe', 'pipe'],
+      });
+    } catch (error) {
+      send({ type: 'error', message: `Failed to start cursor-agent: ${error.message}`, agent: 'cursor' });
+      resolve();
+      return;
+    }
+
+    const entry = { kind: 'cursor', child, startTime: Date.now(), busy: true, key: sessionKey, sessionId: options.sessionId || null };
+    activeSessions.set(sessionKey, entry);
+    let sessionId = options.sessionId || null;
+    let stderr = '';
+    let textOpen = false;
+    let resultSeen = false;
+    let aborted = false;
+    let finalText = '';
+    let thoughtOpen = false;
+    const emittedTexts = new Set();
+
+    const closeText = () => {
+      if (!textOpen) return;
+      textOpen = false;
+      send({ type: 'assistant_stream_end', agent: 'cursor' });
+    };
+    const attachSession = id => {
+      if (!id || sessionId === id) return;
+      sessionId = id;
+      entry.sessionId = id;
+      activeSessions.set(id, entry);
+      if (!options.sessionId) send({ type: 'session-created', sessionId: id, agent: 'cursor' });
+      journal(home, id, { type: 'session_meta', sessionId: id, cwd: options.cwd || null, model: options.model || null, ts: Date.now() });
+      journal(home, id, { type: 'user', content: command || '', ts: Date.now() });
+    };
+    if (options.sessionId) {
+      journal(home, options.sessionId, { type: 'session_meta', sessionId: options.sessionId, cwd: options.cwd || null, model: options.model || null, ts: Date.now() });
+      journal(home, options.sessionId, { type: 'user', content: command || '', ts: Date.now() });
+    }
+    const emitDelta = text => {
+      if (!text) return;
+      if (!textOpen) {
+        textOpen = true;
+        send({ type: 'assistant_stream_start', agent: 'cursor', ts: Date.now() });
+      }
+      send({ type: 'assistant_delta', data: text, agent: 'cursor' });
+      journal(home, sessionId, { type: 'assistant_delta', data: text, ts: Date.now() });
+    };
+
+    child.stderr.on('data', d => { stderr += String(d); });
+    const rl = readline.createInterface({ input: child.stdout, crlfDelay: Infinity });
+    rl.on('line', line => {
+      if (!line.trim()) return;
+      let raw;
+      try { raw = JSON.parse(line); } catch { return; }
+      attachSession(raw.session_id || raw.sessionId);
+      if (raw.type === 'thinking' && raw.subtype === 'delta') {
+        if (!thoughtOpen) {
+          thoughtOpen = true;
+          send({ type: 'thought_stream_start', agent: 'cursor', ts: Date.now() });
+        }
+        send({ type: 'thought_delta', data: raw.text || '', agent: 'cursor' });
+        return;
+      }
+      if (raw.type === 'thinking' && raw.subtype === 'completed' && thoughtOpen) {
+        thoughtOpen = false;
+        send({ type: 'thought_stream_end', agent: 'cursor' });
+        return;
+      }
+      if (raw.type === 'assistant') {
+        const text = textBlocks(raw.message);
+        for (const tool of toolBlocks(raw.message)) {
+          closeText();
+          const input = tool.input ?? tool.args ?? {};
+          send({ type: 'assistant', message: { content: [{ type: 'tool_use', name: tool.name || tool.toolName || 'tool', input }] }, agent: 'cursor' });
+          journal(home, sessionId, { type: 'tool', name: tool.name || tool.toolName || 'tool', input, ts: Date.now() });
+        }
+        // Cursor emits a final assistant message twice in stream-json mode.
+        // Deltas are authoritative; only emit a complete message if no delta
+        // was received for this exact response.
+        if (text && !emittedTexts.has(text)) {
+          emittedTexts.add(text);
+          if (!textOpen) emitDelta(text);
+          finalText = text;
+        }
+        return;
+      }
+      if (raw.type === 'result') {
+        closeText();
+        resultSeen = true;
+        if (raw.is_error || raw.subtype === 'error') {
+          send({ type: 'error', message: raw.result || raw.error || 'Cursor Agent turn failed', agent: 'cursor' });
+        } else {
+          const u = raw.usage || {};
+          const usage = {
+            input_tokens: u.inputTokens ?? u.input_tokens ?? 0,
+            output_tokens: u.outputTokens ?? u.output_tokens ?? 0,
+            cache_read_input_tokens: u.cacheReadTokens ?? u.cache_read_tokens ?? 0,
+            cache_write_input_tokens: u.cacheWriteTokens ?? u.cache_write_tokens ?? 0,
+          };
+          if (raw.result && !finalText) emitDelta(String(raw.result));
+          journal(home, sessionId, { type: 'result', usage, ts: Date.now() });
+          send({ type: 'result', is_error: false, usage, sessionId: sessionId || sessionKey, agent: 'cursor' });
+        }
+      } else if (raw.type === 'error') {
+        send({ type: 'error', message: raw.error?.message || raw.message || 'Cursor Agent error', agent: 'cursor' });
+      }
+    });
+
+    child.on('close', code => {
+      rl.close(); closeText();
+      if (thoughtOpen) send({ type: 'thought_stream_end', agent: 'cursor' });
+      activeSessions.delete(sessionKey);
+      if (sessionId) activeSessions.delete(sessionId);
+      if (aborted) send({ type: 'complete', exitCode: 130, aborted: true, sessionId: sessionId || sessionKey, agent: 'cursor' });
+      else {
+        if (code && !resultSeen) send({ type: 'error', message: stderr.trim() || `cursor-agent exited with code ${code}`, agent: 'cursor' });
+        send({ type: 'complete', exitCode: code || 0, sessionId: sessionId || sessionKey, agent: 'cursor' });
+      }
+      resolve();
+    });
+    child.on('error', error => {
+      activeSessions.delete(sessionKey);
+      if (sessionId) activeSessions.delete(sessionId);
+      send({ type: 'error', message: error.message, agent: 'cursor' });
+      resolve();
+    });
+    entry.abort = () => {
+      aborted = true;
+      try { child.kill('SIGTERM'); } catch {}
+      setTimeout(() => { try { child.kill('SIGKILL'); } catch {} }, 2000).unref?.();
+    };
+  });
+}

package/src/agents/gemini.js

@@ -0,0 +1,182 @@
+import { spawn } from 'child_process';
+import { promises as fs } from 'fs';
+import path from 'path';
+import readline from 'readline';
+import crypto from 'crypto';
+
+// agy (the Antigravity/Gemini CLI) exposes its print mode as NDJSON.  Keeping a
+// small, UI-owned journal alongside its native SQLite conversation store gives
+// the web UI reliable history/search support without depending on the CLI's
+// private protobuf schema.
+function journalPath(geminiHome, sessionId) {
+  return path.join(geminiHome, 'claude-simple-ui', 'sessions', `${sessionId}.jsonl`);
+}
+
+function journal(geminiHome, sessionId, value) {
+  if (!sessionId) return;
+  const file = journalPath(geminiHome, sessionId);
+  fs.mkdir(path.dirname(file), { recursive: true })
+    .then(() => fs.appendFile(file, `${JSON.stringify(value)}\n`, 'utf8'))
+    .catch(() => {});
+}
+
+function isAutoApprove(options) {
+  return options.allowDangerouslySkipPermissions
+    || ['bypassPermissions', 'acceptEdits', 'auto'].includes(options.permissionMode);
+}
+
+function buildArgs(command, options) {
+  const args = ['--output-format', 'stream-json'];
+  if (options.sessionId) args.push('--conversation', options.sessionId);
+  if (options.model) args.push('--model', options.model);
+  if (options.effort && ['low', 'medium', 'high'].includes(options.effort)) {
+    args.push('--effort', options.effort);
+  }
+  // In print mode agy otherwise starts command tools in its scratch directory.
+  // Adding the requested project preserves normal agent access to the workspace.
+  if (options.cwd) args.push('--add-dir', options.cwd);
+  if (isAutoApprove(options)) args.push('--dangerously-skip-permissions');
+  else if (options.permissionMode === 'plan') args.push('--mode', 'plan');
+  else args.push('--mode', 'accept-edits');
+  args.push(`--prompt=${command || ''}`);
+  return args;
+}
+
+function toolInput(update) {
+  const info = update.tool_info || update.toolInfo || {};
+  return info.parameters || info.input || info.args || {};
+}
+
+/** Run a Gemini/Antigravity turn through `agy` print mode. */
+export function runGemini(command, options, send, { cliPath, geminiHome, activeSessions }) {
+  return new Promise(resolve => {
+    const sessionKey = options.sessionId || crypto.randomUUID();
+    const home = geminiHome || path.join(process.env.HOME || '', '.gemini');
+    const args = buildArgs(command, options);
+    // A resumed native conversation may predate the UI journal. Start recording
+    // from this turn so its subsequent history/search/usage is still complete.
+    if (options.sessionId) {
+      journal(home, options.sessionId, {
+        type: 'session_meta', sessionId: options.sessionId, cwd: options.cwd || null,
+        model: options.model || null, ts: Date.now(),
+      });
+      journal(home, options.sessionId, { type: 'user', content: command || '', ts: Date.now() });
+    }
+    let child;
+    try {
+      child = spawn(cliPath || 'agy', args, {
+        cwd: options.cwd || process.cwd(),
+        env: { ...process.env },
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+    } catch (error) {
+      send({ type: 'error', message: `Failed to start agy: ${error.message}`, agent: 'gemini' });
+      resolve();
+      return;
+    }
+
+    const entry = {
+      kind: 'gemini', child, startTime: Date.now(), busy: true,
+      key: sessionKey, sessionId: options.sessionId || null,
+    };
+    activeSessions.set(sessionKey, entry);
+    let sessionId = options.sessionId || null;
+    let stderr = '';
+    let aborted = false;
+    let textOpen = false;
+    let resultSeen = false;
+
+    const closeText = () => {
+      if (!textOpen) return;
+      textOpen = false;
+      send({ type: 'assistant_stream_end', agent: 'gemini' });
+    };
+    const attachSession = id => {
+      if (!id || sessionId === id) return;
+      sessionId = id;
+      entry.sessionId = id;
+      activeSessions.set(id, entry);
+      if (!options.sessionId) send({ type: 'session-created', sessionId: id, agent: 'gemini' });
+      journal(home, id, {
+        type: 'session_meta', sessionId: id, cwd: options.cwd || null,
+        model: options.model || null, ts: Date.now(),
+      });
+      journal(home, id, { type: 'user', content: command || '', ts: Date.now() });
+    };
+    const usage = raw => ({
+      input_tokens: raw?.input_tokens ?? 0,
+      output_tokens: raw?.output_tokens ?? 0,
+      reasoning_tokens: raw?.thinking_tokens ?? 0,
+      cache_read_input_tokens: raw?.cache_read_tokens ?? 0,
+      total_tokens: raw?.total_tokens ?? 0,
+    });
+
+    child.stderr.on('data', d => { stderr += String(d); });
+    const rl = readline.createInterface({ input: child.stdout, crlfDelay: Infinity });
+    rl.on('line', line => {
+      if (!line.trim()) return;
+      let raw;
+      try { raw = JSON.parse(line); } catch { return; }
+      const id = raw.conversation_id || raw.result?.conversation_id || raw.step_update?.conversation_id;
+      attachSession(id);
+
+      if (raw.event === 'step_update') {
+        const update = raw.step_update || {};
+        if (update.step_type === 'agent_response' && update.text_delta) {
+          if (!textOpen) {
+            textOpen = true;
+            send({ type: 'assistant_stream_start', agent: 'gemini', ts: Date.now() });
+          }
+          send({ type: 'assistant_delta', data: update.text_delta, agent: 'gemini' });
+          journal(home, sessionId, { type: 'assistant_delta', data: update.text_delta, ts: Date.now() });
+        }
+        if (update.step_type === 'tool' && update.state === 'ACTIVE') {
+          closeText();
+          const name = update.tool_name || update.toolName || update.tool_info?.name || 'tool';
+          const input = toolInput(update);
+          send({ type: 'assistant', message: { content: [{ type: 'tool_use', name, input }] }, agent: 'gemini' });
+          journal(home, sessionId, { type: 'tool', name, input, ts: Date.now() });
+        }
+        return;
+      }
+      if (raw.event === 'result') {
+        closeText();
+        resultSeen = true;
+        const result = raw.result || {};
+        const u = usage(result.usage);
+        journal(home, sessionId, { type: 'result', usage: u, ts: Date.now() });
+        if (String(result.status || '').toUpperCase() !== 'SUCCESS') {
+          send({ type: 'error', message: result.error || result.response || `Gemini turn ${result.status || 'failed'}`, agent: 'gemini' });
+        } else {
+          send({ type: 'result', is_error: false, usage: u, sessionId: sessionId || sessionKey, agent: 'gemini' });
+        }
+      } else if (raw.event === 'error') {
+        send({ type: 'error', message: raw.error?.message || raw.message || 'Gemini CLI error', agent: 'gemini' });
+      }
+    });
+
+    child.on('close', code => {
+      rl.close();
+      closeText();
+      activeSessions.delete(sessionKey);
+      if (sessionId) activeSessions.delete(sessionId);
+      if (aborted) send({ type: 'complete', exitCode: 130, aborted: true, sessionId: sessionId || sessionKey, agent: 'gemini' });
+      else {
+        if (code && !resultSeen) send({ type: 'error', message: stderr.trim() || `agy exited with code ${code}`, agent: 'gemini' });
+        send({ type: 'complete', exitCode: code || 0, sessionId: sessionId || sessionKey, agent: 'gemini' });
+      }
+      resolve();
+    });
+    child.on('error', error => {
+      activeSessions.delete(sessionKey);
+      if (sessionId) activeSessions.delete(sessionId);
+      send({ type: 'error', message: error.message, agent: 'gemini' });
+      resolve();
+    });
+    entry.abort = () => {
+      aborted = true;
+      try { child.kill('SIGTERM'); } catch {}
+      setTimeout(() => { try { child.kill('SIGKILL'); } catch {} }, 2000).unref?.();
+    };
+  });
+}

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'];
@@ -318,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 = {};
 
@@ -335,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;
 }