Add Gemini CLI as first-class agent

src/__tests__/cli/commands/list-sessions.test.ts

@@ -22,11 +22,12 @@ vi.mock('../../../cli/services/storage', () => ({
 // Mock agent-sessions
 vi.mock('../../../cli/services/agent-sessions', () => ({
 	listClaudeSessions: vi.fn(),
+	listGeminiSessions: vi.fn(),
 }));
 
 import { listSessions } from '../../../cli/commands/list-sessions';
 import { resolveAgentId, getSessionById } from '../../../cli/services/storage';
-import { listClaudeSessions } from '../../../cli/services/agent-sessions';
+import { listClaudeSessions, listGeminiSessions } from '../../../cli/services/agent-sessions';
 
 describe('list sessions command', () => {
 	let consoleSpy: MockInstance;
@@ -255,4 +256,81 @@ describe('list sessions command', () => {
 		expect(consoleSpy).toHaveBeenCalledTimes(1);
 		expect(processExitSpy).not.toHaveBeenCalled();
 	});
+
+	it('should route gemini-cli agents to listGeminiSessions', () => {
+		vi.mocked(resolveAgentId).mockReturnValue('agent-gemini-1');
+		vi.mocked(getSessionById).mockReturnValue(
+			mockAgent({ id: 'agent-gemini-1', name: 'Gemini Agent', toolType: 'gemini-cli' })
+		);
+		vi.mocked(listGeminiSessions).mockReturnValue({
+			sessions: [
+				{
+					sessionId: 'gemini-session-1',
+					sessionName: 'Gemini Session',
+					projectPath: '/path/to/project',
+					timestamp: '2026-02-08T10:00:00.000Z',
+					modifiedAt: '2026-02-08T10:05:00.000Z',
+					firstMessage: 'Help with Gemini',
+					messageCount: 4,
+					sizeBytes: 3000,
+					costUsd: 0,
+					inputTokens: 0,
+					outputTokens: 0,
+					cacheReadTokens: 0,
+					cacheCreationTokens: 0,
+					durationSeconds: 300,
+				},
+			],
+			totalCount: 1,
+			filteredCount: 1,
+		});
+
+		listSessions('agent-gemini', {});
+
+		expect(listGeminiSessions).toHaveBeenCalledWith('/path/to/project', {
+			limit: 25,
+			skip: 0,
+			search: undefined,
+		});
+		expect(listClaudeSessions).not.toHaveBeenCalled();
+		expect(consoleSpy).toHaveBeenCalledTimes(1);
+		expect(consoleSpy.mock.calls[0][0]).toContain('Gemini Agent');
+	});
+
+	it('should route gemini-cli agents to listGeminiSessions in JSON mode', () => {
+		vi.mocked(resolveAgentId).mockReturnValue('agent-gemini-1');
+		vi.mocked(getSessionById).mockReturnValue(
+			mockAgent({ id: 'agent-gemini-1', name: 'Gemini Agent', toolType: 'gemini-cli' })
+		);
+		vi.mocked(listGeminiSessions).mockReturnValue({
+			sessions: [],
+			totalCount: 0,
+			filteredCount: 0,
+		});
+
+		listSessions('agent-gemini', { json: true });
+
+		expect(listGeminiSessions).toHaveBeenCalled();
+		expect(listClaudeSessions).not.toHaveBeenCalled();
+		const output = JSON.parse(consoleSpy.mock.calls[0][0]);
+		expect(output.success).toBe(true);
+		expect(output.agentName).toBe('Gemini Agent');
+	});
+
+	it('should route claude-code agents to listClaudeSessions (not listGeminiSessions)', () => {
+		vi.mocked(resolveAgentId).mockReturnValue('agent-claude-1');
+		vi.mocked(getSessionById).mockReturnValue(
+			mockAgent({ id: 'agent-claude-1', name: 'Claude Agent', toolType: 'claude-code' })
+		);
+		vi.mocked(listClaudeSessions).mockReturnValue({
+			sessions: [],
+			totalCount: 0,
+			filteredCount: 0,
+		});
+
+		listSessions('agent-claude', {});
+
+		expect(listClaudeSessions).toHaveBeenCalled();
+		expect(listGeminiSessions).not.toHaveBeenCalled();
+	});
 });

src/__tests__/cli/commands/run-playbook.test.ts

@@ -45,6 +45,8 @@ vi.mock('../../../cli/services/batch-processor', () => ({
 // Mock the agent-spawner service
 vi.mock('../../../cli/services/agent-spawner', () => ({
 	detectClaude: vi.fn(),
+	detectCodex: vi.fn(),
+	detectGemini: vi.fn(),
 }));
 
 // Mock the jsonl output
@@ -74,7 +76,7 @@ import { runPlaybook } from '../../../cli/commands/run-playbook';
 import { getSessionById } from '../../../cli/services/storage';
 import { findPlaybookById } from '../../../cli/services/playbooks';
 import { runPlaybook as executePlaybook } from '../../../cli/services/batch-processor';
-import { detectClaude } from '../../../cli/services/agent-spawner';
+import { detectClaude, detectCodex, detectGemini } from '../../../cli/services/agent-spawner';
 import { emitError } from '../../../cli/output/jsonl';
 import {
 	formatRunEvent,
@@ -124,12 +126,14 @@ describe('run-playbook command', () => {
 				throw new Error(`process.exit(${code})`);
 			});
 
-		// Default: Claude is available
+		// Default: CLI agents are available
 		vi.mocked(detectClaude).mockResolvedValue({
 			available: true,
 			version: '1.0.0',
 			path: '/usr/local/bin/claude',
 		});
+		vi.mocked(detectCodex).mockResolvedValue({ available: true, path: '/usr/local/bin/codex' });
+		vi.mocked(detectGemini).mockResolvedValue({ available: true, path: '/usr/local/bin/gemini' });
 
 		// Default: agent is not busy
 		vi.mocked(isSessionBusyWithCli).mockReturnValue(false);
@@ -341,6 +345,39 @@ describe('run-playbook command', () => {
 		});
 	});
 
+	describe('Gemini CLI not found', () => {
+		beforeEach(() => {
+			vi.mocked(findPlaybookById).mockReturnValue({
+				playbook: mockPlaybook(),
+				agentId: 'agent-gem',
+			});
+			vi.mocked(getSessionById).mockReturnValue(
+				mockSession({ id: 'agent-gem', toolType: 'gemini-cli' })
+			);
+		});
+
+		it('should error when Gemini CLI is not available (human-readable)', async () => {
+			vi.mocked(detectGemini).mockResolvedValue({ available: false });
+
+			await expect(runPlaybook('pb-123', {})).rejects.toThrow('process.exit(1)');
+
+			expect(formatError).toHaveBeenCalledWith(
+				'Gemini CLI not found. Please install @google/gemini-cli.'
+			);
+		});
+
+		it('should error when Gemini CLI is not available (JSON)', async () => {
+			vi.mocked(detectGemini).mockResolvedValue({ available: false });
+
+			await expect(runPlaybook('pb-123', { json: true })).rejects.toThrow('process.exit(1)');
+
+			expect(emitError).toHaveBeenCalledWith(
+				'Gemini CLI not found. Please install @google/gemini-cli.',
+				'GEMINI_NOT_FOUND'
+			);
+		});
+	});
+
 	describe('playbook not found', () => {
 		it('should error when playbook is not found (human-readable)', async () => {
 			vi.mocked(findPlaybookById).mockImplementation(() => {

src/__tests__/cli/commands/send.test.ts

@@ -18,6 +18,7 @@ vi.mock('../../../cli/services/agent-spawner', () => ({
 	spawnAgent: vi.fn(),
 	detectClaude: vi.fn(),
 	detectCodex: vi.fn(),
+	detectGemini: vi.fn(),
 }));
 
 // Mock storage
@@ -32,7 +33,12 @@ vi.mock('../../../main/parsers/usage-aggregator', () => ({
 }));
 
 import { send } from '../../../cli/commands/send';
-import { spawnAgent, detectClaude, detectCodex } from '../../../cli/services/agent-spawner';
+import {
+	spawnAgent,
+	detectClaude,
+	detectCodex,
+	detectGemini,
+} from '../../../cli/services/agent-spawner';
 import { resolveAgentId, getSessionById } from '../../../cli/services/storage';
 import { estimateContextUsage } from '../../../main/parsers/usage-aggregator';
 
@@ -164,6 +170,27 @@ describe('send command', () => {
 		expect(spawnAgent).toHaveBeenCalledWith('codex', expect.any(String), 'Use codex', undefined);
 	});
 
+	it('should work with gemini-cli agent type', async () => {
+		vi.mocked(resolveAgentId).mockReturnValue('agent-gem-1');
+		vi.mocked(getSessionById).mockReturnValue(
+			mockAgent({ id: 'agent-gem-1', toolType: 'gemini-cli' })
+		);
+		vi.mocked(detectGemini).mockResolvedValue({
+			available: true,
+			path: '/usr/local/bin/gemini',
+		});
+		vi.mocked(spawnAgent).mockResolvedValue({
+			success: true,
+			response: 'Gemini response',
+			agentSessionId: 'gem-session',
+		});
+
+		await send('agent-gem', 'Use gemini', {});
+
+		expect(detectGemini).toHaveBeenCalled();
+		expect(spawnAgent).toHaveBeenCalledWith('gemini-cli', expect.any(String), 'Use gemini', undefined);
+	});
+
 	it('should exit with error when agent ID is not found', async () => {
 		vi.mocked(resolveAgentId).mockImplementation(() => {
 			throw new Error('Agent not found: bad-id');
@@ -204,6 +231,21 @@ describe('send command', () => {
 		expect(processExitSpy).toHaveBeenCalledWith(1);
 	});
 
+	it('should exit with error when Gemini CLI is not found', async () => {
+		vi.mocked(resolveAgentId).mockReturnValue('agent-gem-1');
+		vi.mocked(getSessionById).mockReturnValue(
+			mockAgent({ id: 'agent-gem-1', toolType: 'gemini-cli' })
+		);
+		vi.mocked(detectGemini).mockResolvedValue({ available: false });
+
+		await send('agent-gem', 'Hello', {});
+
+		const output = JSON.parse(consoleSpy.mock.calls[0][0]);
+		expect(output.success).toBe(false);
+		expect(output.code).toBe('GEMINI_NOT_FOUND');
+		expect(processExitSpy).toHaveBeenCalledWith(1);
+	});
+
 	it('should handle agent failure with error in response', async () => {
 		vi.mocked(resolveAgentId).mockReturnValue('agent-abc-123');
 		vi.mocked(getSessionById).mockReturnValue(mockAgent());