@agentrhq/webcmd 0.1.1

package/clis/gemini/ask.test.js

@@ -0,0 +1,1261 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { ArgumentError, CommandExecutionError } from '@agentrhq/webcmd/errors';
+
+const baseline = {
+    turns: [{ Role: 'Assistant', Text: '旧回答' }],
+    transcriptLines: ['baseline'],
+    composerHasText: true,
+    isGenerating: false,
+    structuredTurnsTrusted: true,
+};
+const submission = {
+    snapshot: {
+        turns: [
+            { Role: 'Assistant', Text: '旧回答' },
+            { Role: 'User', Text: '请只回复：OK' },
+        ],
+        transcriptLines: ['baseline', '请只回复：OK'],
+        composerHasText: false,
+        isGenerating: true,
+        structuredTurnsTrusted: true,
+    },
+    preSendAssistantCount: 1,
+    userAnchorTurn: { Role: 'User', Text: '请只回复：OK' },
+    reason: 'user_turn',
+};
+
+const FIXTURE_MODELS = [
+    { model: '2.5-flash', thinkingValues: ['standard', 'extended'] },
+    { model: '2.5-flash-lite', thinkingValues: ['standard'] },
+    { model: '2.5-pro', thinkingValues: ['standard', 'extended'] },
+    { model: '2.5-flash-thinking', thinkingValues: [] },
+];
+
+const mocks = vi.hoisted(() => ({
+    ensureGeminiPage: vi.fn(),
+    getCurrentGeminiModel: vi.fn(),
+    readGeminiSnapshot: vi.fn(),
+    selectGeminiModel: vi.fn(),
+    selectGeminiThinking: vi.fn(),
+    sendGeminiMessage: vi.fn(),
+    startNewGeminiChat: vi.fn(),
+    waitForGeminiSubmission: vi.fn(),
+    waitForGeminiResponse: vi.fn(),
+}));
+
+vi.mock('./utils.js', async () => {
+    const actual = await vi.importActual('./utils.js');
+    return {
+        ...actual,
+        ensureGeminiPage: mocks.ensureGeminiPage,
+        getCurrentGeminiModel: mocks.getCurrentGeminiModel,
+        readGeminiSnapshot: mocks.readGeminiSnapshot,
+        selectGeminiModel: mocks.selectGeminiModel,
+        selectGeminiThinking: mocks.selectGeminiThinking,
+        sendGeminiMessage: mocks.sendGeminiMessage,
+        startNewGeminiChat: mocks.startNewGeminiChat,
+        waitForGeminiSubmission: mocks.waitForGeminiSubmission,
+        waitForGeminiResponse: mocks.waitForGeminiResponse,
+    };
+});
+
+// Mock models.js — stub the split discovery script functions.
+const modelsMock = vi.hoisted(() => ({
+    pickModelPickerScript: vi.fn().mockReturnValue('__PICKER_SCRIPT__'),
+    readMenuModelsScript: vi.fn().mockReturnValue('__READ_MODELS_SCRIPT__'),
+    clickThinkingToggleScript: vi.fn().mockReturnValue('__TOGGLE_SCRIPT__'),
+    extractThinkingScript: vi.fn().mockReturnValue('__EXTRACT_THINKING_SCRIPT__'),
+}));
+vi.mock('./models.js', () => ({
+    pickModelPickerScript: modelsMock.pickModelPickerScript,
+    readMenuModelsScript: modelsMock.readMenuModelsScript,
+    clickThinkingToggleScript: modelsMock.clickThinkingToggleScript,
+    extractThinkingScript: modelsMock.extractThinkingScript,
+    __test__: {
+        pickModelPickerScript: modelsMock.pickModelPickerScript,
+        readMenuModelsScript: modelsMock.readMenuModelsScript,
+        clickThinkingToggleScript: modelsMock.clickThinkingToggleScript,
+        extractThinkingScript: modelsMock.extractThinkingScript,
+    },
+}));
+
+import { askCommand, __test__ } from './ask.js';
+
+const { validateAskModelValue } = __test__;
+
+function createPageMock() {
+    return {
+        goto: vi.fn().mockResolvedValue(undefined),
+        evaluate: vi.fn(),
+        getCookies: vi.fn().mockResolvedValue([]),
+        snapshot: vi.fn().mockResolvedValue(undefined),
+        click: vi.fn().mockResolvedValue(undefined),
+        typeText: vi.fn().mockResolvedValue(undefined),
+        pressKey: vi.fn().mockResolvedValue(undefined),
+        scrollTo: vi.fn().mockResolvedValue(undefined),
+        getFormState: vi.fn().mockResolvedValue({}),
+        wait: vi.fn().mockResolvedValue(undefined),
+        tabs: vi.fn().mockResolvedValue([]),
+        selectTab: vi.fn().mockResolvedValue(undefined),
+        networkRequests: vi.fn().mockResolvedValue([]),
+        consoleMessages: vi.fn().mockResolvedValue([]),
+        scroll: vi.fn().mockResolvedValue(undefined),
+        autoScroll: vi.fn().mockResolvedValue(undefined),
+        installInterceptor: vi.fn().mockResolvedValue(undefined),
+        getInterceptedRequests: vi.fn().mockResolvedValue([]),
+        waitForCapture: vi.fn().mockResolvedValue(undefined),
+        screenshot: vi.fn().mockResolvedValue(''),
+        nativeType: vi.fn().mockResolvedValue(undefined),
+        nativeKeyPress: vi.fn().mockResolvedValue(undefined),
+    };
+}
+
+/**
+ * Set up page.evaluate mocks for the multi-step discovery flow used by ask.
+ *
+ * The ask command opens the picker (evaluate → { ok }), waits, reads
+ * models (evaluate → models[]), then closes the menu (evaluate → anything).
+ */
+function setupDiscoveryMocks(page, models = FIXTURE_MODELS) {
+    vi.mocked(page.evaluate).mockResolvedValueOnce({ ok: true }); // picker click
+    vi.mocked(page.evaluate).mockResolvedValueOnce(models);       // read models
+    vi.mocked(page.evaluate).mockResolvedValueOnce(undefined);    // close menu
+}
+
+function setupDiscoveryWithoutThinking(page, models = FIXTURE_MODELS) {
+    vi.mocked(page.evaluate).mockResolvedValueOnce({ ok: true });
+    vi.mocked(page.evaluate).mockResolvedValueOnce(models);
+    vi.mocked(page.evaluate).mockResolvedValueOnce(undefined);
+}
+
+function setupFailedDiscovery(page, reason = 'Model picker button not found') {
+    vi.mocked(page.evaluate).mockResolvedValueOnce({ ok: false, reason });
+}
+
+function setupDiscoveryNonArray(page) {
+    vi.mocked(page.evaluate).mockResolvedValueOnce({ ok: true });
+    vi.mocked(page.evaluate).mockResolvedValueOnce({ not: 'an array' });
+    vi.mocked(page.evaluate).mockResolvedValueOnce(undefined);
+}
+
+function setupDiscoveryEmpty(page) {
+    vi.mocked(page.evaluate).mockResolvedValueOnce({ ok: true });
+    vi.mocked(page.evaluate).mockResolvedValueOnce([]);
+    vi.mocked(page.evaluate).mockResolvedValueOnce(undefined);
+}
+
+// ── Command registration ─────────────────────────────────────────────────
+
+describe('ask command registration', () => {
+    it('is registered with site=gemini and name=ask', () => {
+        expect(askCommand.site).toBe('gemini');
+        expect(askCommand.name).toBe('ask');
+    });
+
+    it('is access=write', () => {
+        expect(askCommand.access).toBe('write');
+    });
+
+    it('declares response as its output column', () => {
+        expect(askCommand.columns).toEqual(['response']);
+    });
+
+    it('includes --model as an optional string argument', () => {
+        const modelArg = askCommand.args.find((a) => a.name === 'model');
+        expect(modelArg).toBeDefined();
+        expect(modelArg.required).toBe(false);
+        expect(modelArg.type).toBe('string');
+    });
+
+    it('includes --thinking as an optional argument', () => {
+        const thinkingArg = askCommand.args.find((a) => a.name === 'thinking');
+        expect(thinkingArg).toBeDefined();
+        expect(thinkingArg.required).toBe(false);
+    });
+
+    it('still includes prompt, timeout, and new args', () => {
+        const names = askCommand.args.map((a) => a.name);
+        expect(names).toContain('prompt');
+        expect(names).toContain('timeout');
+        expect(names).toContain('new');
+        expect(names).toContain('model');
+        expect(names).toContain('thinking');
+    });
+});
+
+// ── validateAskModelValue ────────────────────────────────────────────────
+
+describe('validateAskModelValue', () => {
+    it('accepts canonical model ids', () => {
+        expect(() => validateAskModelValue('2.5-flash')).not.toThrow();
+        expect(() => validateAskModelValue('2.5-flash-lite')).not.toThrow();
+        expect(() => validateAskModelValue('2.5-pro')).not.toThrow();
+        expect(() => validateAskModelValue('2.5-flash-thinking')).not.toThrow();
+        expect(() => validateAskModelValue('3.1-flash-lite')).not.toThrow();
+        expect(() => validateAskModelValue('3.5-flash')).not.toThrow();
+        expect(() => validateAskModelValue('3.1-pro')).not.toThrow();
+    });
+
+    it('rejects short aliases without version numbers', () => {
+        const msg = 'is not accepted';
+
+        expect(() => validateAskModelValue('pro')).toThrow(ArgumentError);
+        expect(() => validateAskModelValue('pro')).toThrow(msg);
+        expect(() => validateAskModelValue('flash')).toThrow(ArgumentError);
+        expect(() => validateAskModelValue('flash')).toThrow(msg);
+        expect(() => validateAskModelValue('flash-lite')).toThrow(ArgumentError);
+        expect(() => validateAskModelValue('flash-lite')).toThrow(msg);
+        expect(() => validateAskModelValue('lite')).toThrow(ArgumentError);
+        expect(() => validateAskModelValue('thinking')).toThrow(ArgumentError);
+    });
+
+    it('rejects empty string', () => {
+        expect(() => validateAskModelValue('')).toThrow(ArgumentError);
+    });
+
+    it('rejects values missing a variant after version', () => {
+        expect(() => validateAskModelValue('2.5')).toThrow(ArgumentError);
+    });
+
+    it('rejects inverted format (variant first)', () => {
+        expect(() => validateAskModelValue('flash-2.5')).toThrow(ArgumentError);
+    });
+
+    it('mentions webcmd gemini models in error messages', () => {
+        try { validateAskModelValue('pro'); } catch (e) {
+            expect(e.message).toContain('webcmd gemini models');
+        }
+        try { validateAskModelValue('2.5'); } catch (e) {
+            expect(e.message).toContain('webcmd gemini models');
+        }
+    });
+});
+
+/**
+ * Helper: set up the two evaluate calls needed for thinking validation:
+ *   1. discoverModelsScript (via page.evaluate)
+ *   2. getCurrentGeminiModel (mocked separately)
+ */
+function setupDiscoveryAndModel(page, discoveredModels, currentModel) {
+    // Multi-step discovery: picker click → read models → close.
+    vi.mocked(page.evaluate).mockResolvedValueOnce({ ok: true });
+    vi.mocked(page.evaluate).mockResolvedValueOnce(discoveredModels);
+    vi.mocked(page.evaluate).mockResolvedValueOnce(undefined); // close
+    mocks.getCurrentGeminiModel.mockResolvedValueOnce(currentModel);
+}
+
+/**
+ * Helper: set up the full happy-path mocks after thinking validation.
+ */
+function setupHappyPath() {
+    mocks.selectGeminiThinking.mockResolvedValueOnce('Selected');
+    mocks.readGeminiSnapshot.mockResolvedValueOnce(baseline);
+    mocks.sendGeminiMessage.mockResolvedValueOnce('button');
+    mocks.waitForGeminiSubmission.mockResolvedValueOnce(submission);
+    mocks.waitForGeminiResponse.mockResolvedValueOnce('OK');
+}
+
+// ── gemini ask orchestration ─────────────────────────────────────────────
+
+describe('gemini ask orchestration', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    // ── Baseline behavior (no --model) ───────────────────────────────────
+
+    it('captures baseline, sends, waits for confirmed submission, then waits with the remaining timeout', async () => {
+        vi.spyOn(Date, 'now')
+            .mockReturnValueOnce(0)
+            .mockReturnValueOnce(2000);
+        const page = createPageMock();
+        mocks.ensureGeminiPage.mockResolvedValue(undefined);
+        mocks.readGeminiSnapshot.mockResolvedValueOnce(baseline);
+        mocks.sendGeminiMessage.mockResolvedValueOnce('button');
+        mocks.waitForGeminiSubmission.mockResolvedValueOnce(submission);
+        mocks.waitForGeminiResponse.mockResolvedValueOnce('OK');
+
+        const result = await askCommand.func(page, { prompt: '请只回复：OK', timeout: 20, new: 'false' });
+
+        expect(mocks.readGeminiSnapshot).toHaveBeenCalledWith(page);
+        expect(mocks.waitForGeminiSubmission).toHaveBeenCalledWith(page, baseline, 20);
+        expect(mocks.waitForGeminiResponse).toHaveBeenCalledWith(page, submission, '请只回复：OK', 18);
+        expect(result).toEqual([{ response: '💬 OK' }]);
+    });
+
+    it('does not spend extra response wait time after submission has already consumed the full timeout budget', async () => {
+        vi.spyOn(Date, 'now')
+            .mockReturnValueOnce(0)
+            .mockReturnValueOnce(20000);
+        const page = createPageMock();
+        mocks.ensureGeminiPage.mockResolvedValue(undefined);
+        mocks.readGeminiSnapshot.mockResolvedValueOnce(baseline);
+        mocks.sendGeminiMessage.mockResolvedValueOnce('button');
+        mocks.waitForGeminiSubmission.mockResolvedValueOnce(submission);
+        mocks.waitForGeminiResponse.mockResolvedValueOnce('');
+
+        await askCommand.func(page, { prompt: '请只回复：OK', timeout: 20, new: 'false' });
+
+        expect(mocks.waitForGeminiResponse).toHaveBeenCalledWith(page, submission, '请只回复：OK', 0);
+    });
+
+    // ── Omitted --model (no model change) ────────────────────────────────
+
+    it('does not call ensureGeminiPage or selectGeminiModel when --model is omitted', async () => {
+        const page = createPageMock();
+        mocks.ensureGeminiPage.mockResolvedValue(undefined);
+        mocks.readGeminiSnapshot.mockResolvedValueOnce(baseline);
+        mocks.sendGeminiMessage.mockResolvedValueOnce('button');
+        mocks.waitForGeminiSubmission.mockResolvedValueOnce(submission);
+        mocks.waitForGeminiResponse.mockResolvedValueOnce('OK');
+
+        await askCommand.func(page, { prompt: 'hello', timeout: 10, new: 'false' });
+
+        // ensureGeminiPage may be called internally by readGeminiSnapshot/sendGeminiMessage
+        // but selectGeminiModel must NOT be called when --model is absent.
+        expect(mocks.selectGeminiModel).not.toHaveBeenCalled();
+        // page.evaluate (for model discovery) must NOT be called.
+        expect(page.evaluate).not.toHaveBeenCalled();
+    });
+
+    it('does not call selectGeminiModel when --model is undefined', async () => {
+        const page = createPageMock();
+        mocks.ensureGeminiPage.mockResolvedValue(undefined);
+        mocks.readGeminiSnapshot.mockResolvedValueOnce(baseline);
+        mocks.sendGeminiMessage.mockResolvedValueOnce('button');
+        mocks.waitForGeminiSubmission.mockResolvedValueOnce(submission);
+        mocks.waitForGeminiResponse.mockResolvedValueOnce('OK');
+
+        await askCommand.func(page, { prompt: 'hello', timeout: 10, new: 'false' });
+
+        expect(mocks.selectGeminiModel).not.toHaveBeenCalled();
+    });
+
+    // ── Valid model selection ────────────────────────────────────────────
+
+    it('selects the model before readGeminiSnapshot when --model is provided', async () => {
+        const page = createPageMock();
+        mocks.ensureGeminiPage.mockResolvedValue(undefined);
+        setupDiscoveryWithoutThinking(page);
+        mocks.selectGeminiModel.mockResolvedValueOnce(undefined);
+        mocks.readGeminiSnapshot.mockResolvedValueOnce(baseline);
+        mocks.sendGeminiMessage.mockResolvedValueOnce('button');
+        mocks.waitForGeminiSubmission.mockResolvedValueOnce(submission);
+        mocks.waitForGeminiResponse.mockResolvedValueOnce('OK');
+
+        await askCommand.func(page, { prompt: 'hello', model: '2.5-flash', timeout: 10, new: 'false' });
+
+        // Model discovery and selection happen first.
+        expect(mocks.ensureGeminiPage).toHaveBeenCalledWith(page);
+        expect(mocks.ensureGeminiPage).toHaveBeenCalledBefore(page.evaluate);
+        expect(page.evaluate).toHaveBeenCalledTimes(3); // picker click, read models, close
+        expect(mocks.selectGeminiModel).toHaveBeenCalledWith(page, '2.5-flash');
+
+        // Model selection happens before readGeminiSnapshot.
+        expect(mocks.selectGeminiModel).toHaveBeenCalled();
+        expect(mocks.readGeminiSnapshot).toHaveBeenCalled();
+        // Verify ordering: selectGeminiModel called before readGeminiSnapshot
+        const selectCallOrder = mocks.selectGeminiModel.mock.invocationCallOrder[0];
+        const snapshotCallOrder = mocks.readGeminiSnapshot.mock.invocationCallOrder[0];
+        expect(selectCallOrder).toBeLessThan(snapshotCallOrder);
+    });
+
+    it('selects the model before sending the prompt', async () => {
+        const page = createPageMock();
+        mocks.ensureGeminiPage.mockResolvedValue(undefined);
+        setupDiscoveryWithoutThinking(page);
+        mocks.selectGeminiModel.mockResolvedValueOnce(undefined);
+        mocks.readGeminiSnapshot.mockResolvedValueOnce(baseline);
+        mocks.sendGeminiMessage.mockResolvedValueOnce('button');
+        mocks.waitForGeminiSubmission.mockResolvedValueOnce(submission);
+        mocks.waitForGeminiResponse.mockResolvedValueOnce('OK');
+
+        await askCommand.func(page, { prompt: 'hello', model: '2.5-flash', timeout: 10, new: 'false' });
+
+        const selectCallOrder = mocks.selectGeminiModel.mock.invocationCallOrder[0];
+        const sendCallOrder = mocks.sendGeminiMessage.mock.invocationCallOrder[0];
+        expect(selectCallOrder).toBeLessThan(sendCallOrder);
+    });
+
+    it('selects 2.5-pro model successfully', async () => {
+        const page = createPageMock();
+        mocks.ensureGeminiPage.mockResolvedValue(undefined);
+        setupDiscoveryWithoutThinking(page);
+        mocks.selectGeminiModel.mockResolvedValueOnce(undefined);
+        mocks.readGeminiSnapshot.mockResolvedValueOnce(baseline);
+        mocks.sendGeminiMessage.mockResolvedValueOnce('button');
+        mocks.waitForGeminiSubmission.mockResolvedValueOnce(submission);
+        mocks.waitForGeminiResponse.mockResolvedValueOnce('OK');
+
+        const result = await askCommand.func(page, { prompt: 'hello', model: '2.5-pro', timeout: 10, new: 'false' });
+
+        expect(mocks.selectGeminiModel).toHaveBeenCalledWith(page, '2.5-pro');
+        expect(result).toEqual([{ response: '💬 OK' }]);
+    });
+
+    it('selects 2.5-flash-lite model successfully', async () => {
+        const page = createPageMock();
+        mocks.ensureGeminiPage.mockResolvedValue(undefined);
+        setupDiscoveryWithoutThinking(page);
+        mocks.selectGeminiModel.mockResolvedValueOnce(undefined);
+        mocks.readGeminiSnapshot.mockResolvedValueOnce(baseline);
+        mocks.sendGeminiMessage.mockResolvedValueOnce('button');
+        mocks.waitForGeminiSubmission.mockResolvedValueOnce(submission);
+        mocks.waitForGeminiResponse.mockResolvedValueOnce('OK');
+
+        const result = await askCommand.func(page, { prompt: 'hello', model: '2.5-flash-lite', timeout: 10, new: 'false' });
+
+        expect(mocks.selectGeminiModel).toHaveBeenCalledWith(page, '2.5-flash-lite');
+        expect(result).toEqual([{ response: '💬 OK' }]);
+    });
+
+    // ── Alias rejection ──────────────────────────────────────────────────
+
+    it('throws ArgumentError for alias "pro" before any model discovery', async () => {
+        const page = createPageMock();
+        mocks.ensureGeminiPage.mockResolvedValue(undefined);
+
+        await expect(
+            askCommand.func(page, { prompt: 'hello', model: 'pro', timeout: 10, new: 'false' })
+        ).rejects.toBeInstanceOf(ArgumentError);
+
+        // Must not call page.evaluate (no discovery attempted).
+        expect(page.evaluate).not.toHaveBeenCalled();
+        expect(mocks.selectGeminiModel).not.toHaveBeenCalled();
+    });
+
+    it('throws ArgumentError for alias "flash" before any model discovery', async () => {
+        const page = createPageMock();
+
+        await expect(
+            askCommand.func(page, { prompt: 'hello', model: 'flash', timeout: 10, new: 'false' })
+        ).rejects.toBeInstanceOf(ArgumentError);
+
+        expect(page.evaluate).not.toHaveBeenCalled();
+    });
+
+    it('throws ArgumentError for alias "flash-lite" before any model discovery', async () => {
+        const page = createPageMock();
+
+        await expect(
+            askCommand.func(page, { prompt: 'hello', model: 'flash-lite', timeout: 10, new: 'false' })
+        ).rejects.toBeInstanceOf(ArgumentError);
+
+        expect(page.evaluate).not.toHaveBeenCalled();
+    });
+
+    it('rejects aliases with error message mentioning canonical ids and webcmd gemini models', async () => {
+        const page = createPageMock();
+
+        try {
+            await askCommand.func(page, { prompt: 'hello', model: 'pro', timeout: 10, new: 'false' });
+            expect.fail('Expected ArgumentError');
+        } catch (e) {
+            expect(e).toBeInstanceOf(ArgumentError);
+            expect(e.message).toContain('not accepted');
+            expect(e.message).toContain('webcmd gemini models');
+        }
+    });
+
+    // ── Invalid / unavailable model ──────────────────────────────────────
+
+    it('throws ArgumentError for a model id not in the discovered list', async () => {
+        const page = createPageMock();
+        mocks.ensureGeminiPage.mockResolvedValue(undefined);
+        setupDiscoveryWithoutThinking(page);
+
+        await expect(
+            askCommand.func(page, { prompt: 'hello', model: '99.9-nonexistent', timeout: 10, new: 'false' })
+        ).rejects.toBeInstanceOf(ArgumentError);
+
+        // Discovery was attempted.
+        expect(page.evaluate).toHaveBeenCalledTimes(3);
+        // But model was not selected.
+        expect(mocks.selectGeminiModel).not.toHaveBeenCalled();
+        // And no snapshot or send happened.
+        expect(mocks.readGeminiSnapshot).not.toHaveBeenCalled();
+        expect(mocks.sendGeminiMessage).not.toHaveBeenCalled();
+    });
+
+    it('includes available models and suggests webcmd gemini models in invalid-model error', async () => {
+        const page = createPageMock();
+        mocks.ensureGeminiPage.mockResolvedValue(undefined);
+        setupDiscoveryWithoutThinking(page);
+
+        try {
+            await askCommand.func(page, { prompt: 'hello', model: '99.9-nonexistent', timeout: 10, new: 'false' });
+            expect.fail('Expected ArgumentError');
+        } catch (e) {
+            expect(e).toBeInstanceOf(ArgumentError);
+            expect(e.message).toContain('99.9-nonexistent');
+            expect(e.message).toContain('Available models');
+            expect(e.message).toContain('2.5-flash');
+            expect(e.message).toContain('2.5-pro');
+            expect(e.message).toContain('webcmd gemini models');
+        }
+    });
+
+    it('throws when model discovery returns non-array data', async () => {
+        const page = createPageMock();
+        mocks.ensureGeminiPage.mockResolvedValue(undefined);
+        setupDiscoveryNonArray(page);
+
+        await expect(
+            askCommand.func(page, { prompt: 'hello', model: '2.5-flash', timeout: 10, new: 'false' })
+        ).rejects.toBeInstanceOf(CommandExecutionError);
+    });
+
+    it('typed-fails malformed Browser Bridge envelopes during model discovery', async () => {
+        const page = createPageMock();
+        mocks.ensureGeminiPage.mockResolvedValue(undefined);
+        vi.mocked(page.evaluate).mockResolvedValueOnce({ ok: true });
+        vi.mocked(page.evaluate).mockResolvedValueOnce({ session: 'site:gemini' });
+
+        await expect(
+            askCommand.func(page, { prompt: 'hello', model: '2.5-flash', timeout: 10, new: 'false' })
+        ).rejects.toBeInstanceOf(CommandExecutionError);
+
+        expect(mocks.selectGeminiModel).not.toHaveBeenCalled();
+        expect(mocks.readGeminiSnapshot).not.toHaveBeenCalled();
+        expect(mocks.sendGeminiMessage).not.toHaveBeenCalled();
+    });
+
+    // ── Browser Bridge envelope unwrap ───────────────────────────────────
+
+    it('unwraps Browser Bridge envelope { session, data } for model discovery', async () => {
+        const page = createPageMock();
+        mocks.ensureGeminiPage.mockResolvedValue(undefined);
+        // The envelope is returned by readMenuModelsScript.
+        vi.mocked(page.evaluate).mockResolvedValueOnce({ ok: true }); // picker click
+        vi.mocked(page.evaluate).mockResolvedValueOnce({
+            session: 'site:gemini',
+            data: FIXTURE_MODELS,
+        }); // read models
+        vi.mocked(page.evaluate).mockResolvedValueOnce(false); // toggle
+        vi.mocked(page.evaluate).mockResolvedValueOnce(undefined); // close
+        mocks.selectGeminiModel.mockResolvedValueOnce(undefined);
+        mocks.readGeminiSnapshot.mockResolvedValueOnce(baseline);
+        mocks.sendGeminiMessage.mockResolvedValueOnce('button');
+        mocks.waitForGeminiSubmission.mockResolvedValueOnce(submission);
+        mocks.waitForGeminiResponse.mockResolvedValueOnce('OK');
+
+        const result = await askCommand.func(page, { prompt: 'hello', model: '2.5-flash', timeout: 10, new: 'false' });
+
+        expect(mocks.selectGeminiModel).toHaveBeenCalledWith(page, '2.5-flash');
+        expect(result).toEqual([{ response: '💬 OK' }]);
+    });
+
+    it('handles empty model discovery result gracefully', async () => {
+        const page = createPageMock();
+        mocks.ensureGeminiPage.mockResolvedValue(undefined);
+        setupDiscoveryEmpty(page);
+
+        await expect(
+            askCommand.func(page, { prompt: 'hello', model: '2.5-flash', timeout: 10, new: 'false' })
+        ).rejects.toBeInstanceOf(CommandExecutionError);
+    });
+
+    // ── Ordering and state ───────────────────────────────────────────────
+
+    it('does not restore previous model after completion', async () => {
+        // The ask command selects the model and does not revert it.
+        // This test verifies that selectGeminiModel is only called once
+        // (for selection) and never called again (for restoration).
+        const page = createPageMock();
+        mocks.ensureGeminiPage.mockResolvedValue(undefined);
+        setupDiscoveryWithoutThinking(page);
+        mocks.selectGeminiModel.mockResolvedValueOnce(undefined);
+        mocks.readGeminiSnapshot.mockResolvedValueOnce(baseline);
+        mocks.sendGeminiMessage.mockResolvedValueOnce('button');
+        mocks.waitForGeminiSubmission.mockResolvedValueOnce(submission);
+        mocks.waitForGeminiResponse.mockResolvedValueOnce('OK');
+
+        await askCommand.func(page, { prompt: 'hello', model: '2.5-flash', timeout: 10, new: 'false' });
+
+        // selectGeminiModel is called exactly once (for selection, not restoration).
+        expect(mocks.selectGeminiModel).toHaveBeenCalledTimes(1);
+    });
+
+    it('does not mutate other Gemini commands — only ask accepts --model', () => {
+        // Other Gemini commands (image, deep research, etc.) are in separate
+        // files and do not import model selection.  This test confirms ask
+        // is the only command that declares --model within gemini.
+        const modelArg = askCommand.args.find((a) => a.name === 'model');
+        expect(modelArg).toBeDefined();
+        // The model arg is on ask only; other commands are unchanged.
+    });
+
+    // ── Model selection + --new interaction ──────────────────────────────
+
+    it('starts new chat, then selects model when both --model and --new=true', async () => {
+        const page = createPageMock();
+        mocks.ensureGeminiPage.mockResolvedValue(undefined);
+        mocks.startNewGeminiChat.mockResolvedValueOnce('clicked');
+        setupDiscoveryWithoutThinking(page);
+        mocks.selectGeminiModel.mockResolvedValueOnce(undefined);
+        mocks.readGeminiSnapshot.mockResolvedValueOnce(baseline);
+        mocks.sendGeminiMessage.mockResolvedValueOnce('button');
+        mocks.waitForGeminiSubmission.mockResolvedValueOnce(submission);
+        mocks.waitForGeminiResponse.mockResolvedValueOnce('OK');
+
+        await askCommand.func(page, { prompt: 'hello', model: '2.5-flash', timeout: 10, new: 'true' });
+
+        // New chat happens first, then model selection.
+        const newChatCallOrder = mocks.startNewGeminiChat.mock.invocationCallOrder[0];
+        const selectCallOrder = mocks.selectGeminiModel.mock.invocationCallOrder[0];
+        expect(newChatCallOrder).toBeLessThan(selectCallOrder);
+    });
+});
+
+describe('gemini ask thinking selection', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    // ── Valid thinking selection (current model matched) ─────────────
+    it('selects standard thinking when current model supports it', async () => {
+        vi.spyOn(Date, 'now')
+            .mockReturnValueOnce(0)
+            .mockReturnValueOnce(2000);
+        const page = createPageMock();
+        setupDiscoveryAndModel(page,
+            [{ model: '2.5-flash', thinkingValues: ['standard', 'extended'] }],
+            '2.5-flash',
+        );
+        setupHappyPath();
+
+        const result = await askCommand.func(page, {
+            prompt: '请只回复：OK', timeout: 20, new: 'false', thinking: 'standard',
+        });
+
+        expect(mocks.selectGeminiThinking).toHaveBeenCalledWith(page, 'standard');
+        const selectCall = mocks.selectGeminiThinking.mock.invocationCallOrder[0];
+        const snapshotCall = mocks.readGeminiSnapshot.mock.invocationCallOrder[0];
+        expect(selectCall).toBeLessThan(snapshotCall);
+        expect(result).toEqual([{ response: '💬 OK' }]);
+    });
+
+    it('selects extended thinking when current model supports it', async () => {
+        vi.spyOn(Date, 'now')
+            .mockReturnValueOnce(0)
+            .mockReturnValueOnce(2000);
+        const page = createPageMock();
+        setupDiscoveryAndModel(page,
+            [{ model: '2.5-pro', thinkingValues: ['standard', 'extended'] }],
+            '2.5-pro',
+        );
+        setupHappyPath();
+
+        const result = await askCommand.func(page, {
+            prompt: 'test', timeout: 20, new: 'false', thinking: 'extended',
+        });
+
+        expect(mocks.selectGeminiThinking).toHaveBeenCalledWith(page, 'extended');
+        expect(result[0].response).toContain('OK');
+    });
+
+    it('selects thinking with --new true: new chat before thinking before snapshot', async () => {
+        vi.spyOn(Date, 'now')
+            .mockReturnValueOnce(0)
+            .mockReturnValueOnce(2000);
+        const page = createPageMock();
+        setupDiscoveryAndModel(page,
+            [{ model: '2.5-flash', thinkingValues: ['standard', 'extended'] }],
+            '2.5-flash',
+        );
+        mocks.startNewGeminiChat.mockResolvedValueOnce('navigate');
+        setupHappyPath();
+
+        await askCommand.func(page, {
+            prompt: 'test', timeout: 20, new: 'true', thinking: 'standard',
+        });
+
+        const newChatCall = mocks.startNewGeminiChat.mock.invocationCallOrder[0];
+        const thinkingCall = mocks.selectGeminiThinking.mock.invocationCallOrder[0];
+        const snapshotCall = mocks.readGeminiSnapshot.mock.invocationCallOrder[0];
+        expect(newChatCall).toBeLessThan(thinkingCall);
+        expect(thinkingCall).toBeLessThan(snapshotCall);
+    });
+
+    // ── Invalid thinking value (not standard or extended) ────────────
+    it('rejects invalid thinking value with ArgumentError', async () => {
+        const page = createPageMock();
+        let err;
+        try {
+            await askCommand.func(page, {
+                prompt: 'test', timeout: 20, thinking: 'invalid',
+            });
+        } catch (e) { err = e; }
+        expect(err).toBeInstanceOf(ArgumentError);
+        expect(err.message).toContain("--thinking must be 'standard' or 'extended'");
+        expect(mocks.selectGeminiThinking).not.toHaveBeenCalled();
+        expect(mocks.readGeminiSnapshot).not.toHaveBeenCalled();
+        expect(mocks.sendGeminiMessage).not.toHaveBeenCalled();
+    });
+
+    it('rejects empty thinking value', async () => {
+        const page = createPageMock();
+        let err;
+        try {
+            await askCommand.func(page, { prompt: 'test', timeout: 20, thinking: '' });
+        } catch (e) { err = e; }
+        expect(err).toBeInstanceOf(ArgumentError);
+        expect(err.message).toContain("--thinking must be 'standard' or 'extended'");
+    });
+
+    // ── Current-model-scoped validation ──────────────────────────────
+    it('rejects thinking not available for the current model (cross-model mismatch)', async () => {
+        const page = createPageMock();
+        // Two models: 2.5-flash supports 'standard' only, 2.5-pro supports extended.
+        // Current model is 2.5-flash, but user requests 'extended'.
+        setupDiscoveryAndModel(page,
+            [
+                { model: '2.5-flash', thinkingValues: ['standard'] },
+                { model: '2.5-pro', thinkingValues: ['standard', 'extended'] },
+            ],
+            '2.5-flash',
+        );
+
+        let err;
+        try {
+            await askCommand.func(page, {
+                prompt: 'test', timeout: 20, thinking: 'extended',
+            });
+        } catch (e) { err = e; }
+        expect(err).toBeInstanceOf(ArgumentError);
+        expect(err.message).toContain("not available for the current model");
+        expect(err.message).toContain("2.5-flash");
+        expect(err.hint).toContain("standard");
+        // Must NOT mention 'extended' as available (it's not on this model).
+        expect(err.hint).not.toContain("extended");
+
+        expect(mocks.selectGeminiThinking).not.toHaveBeenCalled();
+        expect(mocks.readGeminiSnapshot).not.toHaveBeenCalled();
+    });
+
+    it('attempts thinking selection when current model has no reliable per-model thinking data', async () => {
+        const page = createPageMock();
+        setupDiscoveryAndModel(page,
+            [{ model: '2.5-flash-lite', thinkingValues: [] }],
+            '2.5-flash-lite',
+        );
+        mocks.selectGeminiThinking.mockResolvedValueOnce('');
+
+        let err;
+        try {
+            await askCommand.func(page, {
+                prompt: 'test', timeout: 20, thinking: 'standard',
+            });
+        } catch (e) { err = e; }
+        expect(err).toBeInstanceOf(ArgumentError);
+        expect(err.message).toContain("Could not select thinking level");
+
+        expect(mocks.selectGeminiThinking).toHaveBeenCalledWith(page, 'standard');
+    });
+
+    // ── Union fallback when current model unknown ────────────────────
+    it('falls back to union validation when current model is empty', async () => {
+        const page = createPageMock();
+        setupDiscoveryAndModel(page,
+            [{ model: '2.5-flash', thinkingValues: ['standard'] }],
+            '',  // current model unknown → union fallback
+        );
+
+        let err;
+        try {
+            await askCommand.func(page, {
+                prompt: 'test', timeout: 20, thinking: 'extended',
+            });
+        } catch (e) { err = e; }
+        expect(err).toBeInstanceOf(ArgumentError);
+        expect(err.message).toContain("not currently available");
+        expect(err.hint).toContain("standard");
+    });
+
+    it('falls back to union when current model not found in discovered set', async () => {
+        const page = createPageMock();
+        setupDiscoveryAndModel(page,
+            [{ model: '2.5-flash', thinkingValues: ['standard'] }],
+            '3.0-unknown-model',  // not in discovered set
+        );
+
+        let err;
+        try {
+            await askCommand.func(page, {
+                prompt: 'test', timeout: 20, thinking: 'extended',
+            });
+        } catch (e) { err = e; }
+        expect(err).toBeInstanceOf(ArgumentError);
+        expect(err.message).toContain("not currently available");
+    });
+
+    // ── Graceful degradation when discovery returns empty ────────────
+    it('proceeds when discovery returns empty', async () => {
+        vi.spyOn(Date, 'now')
+            .mockReturnValueOnce(0)
+            .mockReturnValueOnce(2000);
+        const page = createPageMock();
+        setupDiscoveryAndModel(page, [], '');
+        setupHappyPath();
+
+        const result = await askCommand.func(page, {
+            prompt: 'test', timeout: 20, thinking: 'standard',
+        });
+        expect(mocks.selectGeminiThinking).toHaveBeenCalledWith(page, 'standard');
+        expect(result[0].response).toContain('OK');
+    });
+
+    it('does not reject empty thinkingValues as unsupported because they mean unknown support', async () => {
+        vi.spyOn(Date, 'now')
+            .mockReturnValueOnce(0)
+            .mockReturnValueOnce(2000);
+        const page = createPageMock();
+        setupDiscoveryAndModel(page,
+            [{ model: '2.5-flash', thinkingValues: [] }],
+            '2.5-flash',
+        );
+        setupHappyPath();
+
+        const result = await askCommand.func(page, {
+            prompt: 'test', timeout: 20, thinking: 'extended',
+        });
+
+        expect(mocks.selectGeminiThinking).toHaveBeenCalledWith(page, 'extended');
+        expect(result[0].response).toContain('OK');
+    });
+
+    // ── Failed thinking selection ────────────────────────────────────
+    it('throws when selectGeminiThinking returns empty after successful validation', async () => {
+        const page = createPageMock();
+        setupDiscoveryAndModel(page,
+            [{ model: '2.5-flash', thinkingValues: ['standard', 'extended'] }],
+            '2.5-flash',
+        );
+        mocks.selectGeminiThinking.mockResolvedValueOnce('');  // failed selection
+
+        let err;
+        try {
+            await askCommand.func(page, {
+                prompt: 'test', timeout: 20, thinking: 'standard',
+            });
+        } catch (e) { err = e; }
+        expect(err).toBeInstanceOf(ArgumentError);
+        expect(err.message).toContain("Could not select thinking level");
+
+        // Must not proceed to snapshot or send.
+        expect(mocks.readGeminiSnapshot).not.toHaveBeenCalled();
+        expect(mocks.sendGeminiMessage).not.toHaveBeenCalled();
+    });
+
+    it('failed selection hint includes model-specific info when current model known', async () => {
+        const page = createPageMock();
+        setupDiscoveryAndModel(page,
+            [{ model: '2.5-flash', thinkingValues: ['standard', 'extended'] }],
+            '2.5-flash',
+        );
+        mocks.selectGeminiThinking.mockResolvedValueOnce('');
+
+        let err;
+        try {
+            await askCommand.func(page, {
+                prompt: 'test', timeout: 20, thinking: 'extended',
+            });
+        } catch (e) { err = e; }
+        expect(err).toBeInstanceOf(ArgumentError);
+        expect(err.hint).toContain("2.5-flash");
+        expect(err.hint).toContain("standard");
+        expect(err.hint).toContain("extended");
+        expect(err.hint).toContain("gemini models");
+    });
+
+    // ── Omitted thinking ─────────────────────────────────────────────
+    it('omitted --thinking does not call selectGeminiThinking', async () => {
+        vi.spyOn(Date, 'now')
+            .mockReturnValueOnce(0)
+            .mockReturnValueOnce(2000);
+        const page = createPageMock();
+        mocks.readGeminiSnapshot.mockResolvedValueOnce(baseline);
+        mocks.sendGeminiMessage.mockResolvedValueOnce('button');
+        mocks.waitForGeminiSubmission.mockResolvedValueOnce(submission);
+        mocks.waitForGeminiResponse.mockResolvedValueOnce('OK');
+
+        await askCommand.func(page, { prompt: 'test', timeout: 20, new: 'false' });
+        expect(mocks.selectGeminiThinking).not.toHaveBeenCalled();
+    });
+
+    it('null thinking does not call selectGeminiThinking', async () => {
+        vi.spyOn(Date, 'now')
+            .mockReturnValueOnce(0)
+            .mockReturnValueOnce(2000);
+        const page = createPageMock();
+        mocks.readGeminiSnapshot.mockResolvedValueOnce(baseline);
+        mocks.sendGeminiMessage.mockResolvedValueOnce('button');
+        mocks.waitForGeminiSubmission.mockResolvedValueOnce(submission);
+        mocks.waitForGeminiResponse.mockResolvedValueOnce('OK');
+
+        await askCommand.func(page, { prompt: 'test', timeout: 20, thinking: null });
+        expect(mocks.selectGeminiThinking).not.toHaveBeenCalled();
+    });
+
+    // ── Case insensitivity ───────────────────────────────────────────
+    it('accepts uppercase thinking value', async () => {
+        vi.spyOn(Date, 'now')
+            .mockReturnValueOnce(0)
+            .mockReturnValueOnce(2000);
+        const page = createPageMock();
+        setupDiscoveryAndModel(page,
+            [{ model: '2.5-flash', thinkingValues: ['standard', 'extended'] }],
+            '2.5-flash',
+        );
+        setupHappyPath();
+
+        const result = await askCommand.func(page, {
+            prompt: 'test', timeout: 20, thinking: 'STANDARD',
+        });
+        expect(mocks.selectGeminiThinking).toHaveBeenCalledWith(page, 'standard');
+        expect(result[0].response).toContain('OK');
+    });
+
+    it('accepts mixed-case thinking value', async () => {
+        vi.spyOn(Date, 'now')
+            .mockReturnValueOnce(0)
+            .mockReturnValueOnce(2000);
+        const page = createPageMock();
+        setupDiscoveryAndModel(page,
+            [{ model: '2.5-flash', thinkingValues: ['standard', 'extended'] }],
+            '2.5-flash',
+        );
+        setupHappyPath();
+
+        const result = await askCommand.func(page, {
+            prompt: 'test', timeout: 20, thinking: 'ExTeNdEd',
+        });
+        expect(mocks.selectGeminiThinking).toHaveBeenCalledWith(page, 'extended');
+        expect(result[0].response).toContain('OK');
+    });
+
+    // ── Does not restore thinking after completion ───────────────────
+    it('does not call selectGeminiThinking again after send', async () => {
+        vi.spyOn(Date, 'now')
+            .mockReturnValueOnce(0)
+            .mockReturnValueOnce(2000);
+        const page = createPageMock();
+        setupDiscoveryAndModel(page,
+            [{ model: '2.5-flash', thinkingValues: ['standard', 'extended'] }],
+            '2.5-flash',
+        );
+        setupHappyPath();
+
+        await askCommand.func(page, {
+            prompt: 'test', timeout: 20, thinking: 'standard',
+        });
+        expect(mocks.selectGeminiThinking).toHaveBeenCalledTimes(1);
+    });
+
+    // ── --model + --thinking integration ───────────────────────────
+    it('scopes thinking validation to the selected model when --model is supplied', async () => {
+        vi.spyOn(Date, 'now')
+            .mockReturnValueOnce(0)
+            .mockReturnValueOnce(2000);
+        const page = createPageMock();
+        mocks.ensureGeminiPage.mockResolvedValue(undefined);
+        setupDiscoveryMocks(page);
+        mocks.selectGeminiModel.mockResolvedValueOnce(undefined);
+        // getCurrentGeminiModel should NOT be called because --model overrides it
+        mocks.getCurrentGeminiModel.mockResolvedValue('2.5-flash');
+        setupHappyPath();
+
+        const result = await askCommand.func(page, {
+            prompt: 'test', timeout: 20, new: 'false',
+            model: '2.5-pro', thinking: 'extended',
+        });
+
+        // Thinking validated against selected model (2.5-pro), not current (2.5-flash).
+        expect(mocks.selectGeminiThinking).toHaveBeenCalledWith(page, 'extended');
+        // getCurrentGeminiModel should NOT have been called when --model is supplied.
+        expect(mocks.getCurrentGeminiModel).not.toHaveBeenCalled();
+        expect(result[0].response).toContain('OK');
+    });
+
+    it('rejects thinking not available for the selected model (--model + --thinking mismatch)', async () => {
+        const page = createPageMock();
+        mocks.ensureGeminiPage.mockResolvedValue(undefined);
+        // Multi-step discovery WITHOUT thinking extraction so per-model
+        // thinkingValues from the discovery data are preserved.
+        setupDiscoveryWithoutThinking(page, [
+            { model: '2.5-flash', thinkingValues: ['standard'] },
+            { model: '2.5-pro', thinkingValues: ['standard', 'extended'] },
+        ]);
+        mocks.selectGeminiModel.mockResolvedValueOnce(undefined);
+
+        let err;
+        try {
+            await askCommand.func(page, {
+                prompt: 'test', timeout: 20,
+                model: '2.5-flash', thinking: 'extended',
+            });
+        } catch (e) { err = e; }
+        expect(err).toBeInstanceOf(ArgumentError);
+        expect(err.message).toContain("not available for the selected model");
+        expect(err.message).toContain("2.5-flash");
+        expect(err.hint).toContain("standard");
+        expect(err.hint).not.toContain("extended");
+
+        expect(mocks.selectGeminiThinking).not.toHaveBeenCalled();
+        expect(mocks.readGeminiSnapshot).not.toHaveBeenCalled();
+    });
+
+
+    it('does not treat global/current thinking controls as selected-model support when rows have no per-model data', async () => {
+        vi.spyOn(Date, 'now')
+            .mockReturnValueOnce(0)
+            .mockReturnValueOnce(2000);
+        const page = createPageMock();
+        mocks.ensureGeminiPage.mockResolvedValue(undefined);
+        setupDiscoveryWithoutThinking(page, [
+            { model: '2.5-flash', thinkingValues: [] },
+            { model: '2.5-pro', thinkingValues: [] },
+        ]);
+        mocks.selectGeminiModel.mockResolvedValueOnce(undefined);
+        setupHappyPath();
+
+        const result = await askCommand.func(page, {
+            prompt: 'test', timeout: 20,
+            model: '2.5-flash', thinking: 'extended',
+        });
+
+        expect(mocks.selectGeminiThinking).toHaveBeenCalledWith(page, 'extended');
+        expect(result[0].response).toContain('OK');
+    });
+
+    it('unwraps Browser Bridge envelope for thinking discovery before scoped validation', async () => {
+        const page = createPageMock();
+        mocks.ensureGeminiPage.mockResolvedValue(undefined);
+        // Multi-step discovery: picker click → envelope-wrapped read → close.
+        vi.mocked(page.evaluate).mockResolvedValueOnce({ ok: true });
+        vi.mocked(page.evaluate).mockResolvedValueOnce({
+            session: 'site:gemini',
+            data: [
+                { model: '2.5-flash', thinkingValues: ['standard'] },
+                { model: '2.5-pro', thinkingValues: ['standard', 'extended'] },
+            ],
+        });
+        vi.mocked(page.evaluate).mockResolvedValueOnce(undefined); // close
+        mocks.selectGeminiModel.mockResolvedValueOnce(undefined);
+
+        let err;
+        try {
+            await askCommand.func(page, {
+                prompt: 'test', timeout: 20,
+                model: '2.5-flash', thinking: 'extended',
+            });
+        } catch (e) { err = e; }
+        expect(err).toBeInstanceOf(ArgumentError);
+        expect(err.message).toContain('not available for the selected model');
+        expect(err.hint).toContain('standard');
+        expect(err.hint).not.toContain('extended');
+
+        expect(mocks.selectGeminiThinking).not.toHaveBeenCalled();
+        expect(mocks.readGeminiSnapshot).not.toHaveBeenCalled();
+    });
+
+    it('uses current model for scoping when --model is omitted (unchanged behavior)', async () => {
+        const page = createPageMock();
+        setupDiscoveryAndModel(page,
+            [{ model: '2.5-flash', thinkingValues: ['standard', 'extended'] }],
+            '2.5-flash',
+        );
+        setupHappyPath();
+
+        const result = await askCommand.func(page, {
+            prompt: 'test', timeout: 20, new: 'false', thinking: 'standard',
+        });
+
+        expect(mocks.getCurrentGeminiModel).toHaveBeenCalled();
+        expect(mocks.selectGeminiThinking).toHaveBeenCalledWith(page, 'standard');
+        expect(result[0].response).toContain('OK');
+    });
+
+    // ── Error message suggests gemini models ────────────────────────
+    it('error hint suggests gemini models for invalid values', async () => {
+        const page = createPageMock();
+        let err;
+        try {
+            await askCommand.func(page, { prompt: 'test', timeout: 20, thinking: 'bad-value' });
+        } catch (e) { err = e; }
+        expect(err).toBeInstanceOf(ArgumentError);
+        expect(err.hint).toContain('gemini models');
+    });
+
+    it('invalid thinking value caught by first check does not trigger discovery', async () => {
+        const page = createPageMock();
+        try {
+            await askCommand.func(page, { prompt: 'test', timeout: 20, thinking: 'bad' });
+        } catch (_) {}
+        // First check should catch it; neither discovery nor current-model lookup runs.
+        expect(page.evaluate).not.toHaveBeenCalled();
+        expect(mocks.getCurrentGeminiModel).not.toHaveBeenCalled();
+    });
+
+    // ── Combined --model + --thinking + --new true ordering ─────────
+
+    it('discovers models once when both --model and --thinking are supplied', async () => {
+        vi.spyOn(Date, 'now')
+            .mockReturnValueOnce(0)
+            .mockReturnValueOnce(2000);
+        const page = createPageMock();
+        mocks.ensureGeminiPage.mockResolvedValue(undefined);
+        setupDiscoveryMocks(page);
+        mocks.selectGeminiModel.mockResolvedValueOnce(undefined);
+        setupHappyPath();
+
+        await askCommand.func(page, {
+            prompt: 'test', timeout: 20, new: 'false',
+            model: '2.5-flash', thinking: 'standard',
+        });
+
+        // page.evaluate is called 3 times (picker, read, close).
+        expect(page.evaluate).toHaveBeenCalledTimes(3);
+    });
+
+    it('applies model and thinking before snapshot when both flags are supplied (no --new)', async () => {
+        vi.spyOn(Date, 'now')
+            .mockReturnValueOnce(0)
+            .mockReturnValueOnce(2000);
+        const page = createPageMock();
+        mocks.ensureGeminiPage.mockResolvedValue(undefined);
+        setupDiscoveryMocks(page);
+        mocks.selectGeminiModel.mockResolvedValueOnce(undefined);
+        setupHappyPath();
+
+        await askCommand.func(page, {
+            prompt: 'test', timeout: 20, new: 'false',
+            model: '2.5-flash', thinking: 'standard',
+        });
+
+        // Model selection before thinking selection.
+        const modelCall = mocks.selectGeminiModel.mock.invocationCallOrder[0];
+        const thinkingCall = mocks.selectGeminiThinking.mock.invocationCallOrder[0];
+        expect(modelCall).toBeLessThan(thinkingCall);
+
+        // Thinking selection before snapshot.
+        const snapshotCall = mocks.readGeminiSnapshot.mock.invocationCallOrder[0];
+        expect(thinkingCall).toBeLessThan(snapshotCall);
+    });
+
+    it('applies --new true, model, and thinking in correct order', async () => {
+        vi.spyOn(Date, 'now')
+            .mockReturnValueOnce(0)
+            .mockReturnValueOnce(2000);
+        const page = createPageMock();
+        mocks.ensureGeminiPage.mockResolvedValue(undefined);
+        mocks.startNewGeminiChat.mockResolvedValueOnce('clicked');
+        setupDiscoveryMocks(page);
+        mocks.selectGeminiModel.mockResolvedValueOnce(undefined);
+        setupHappyPath();
+
+        await askCommand.func(page, {
+            prompt: 'test', timeout: 20,
+            new: 'true', model: '2.5-flash', thinking: 'standard',
+        });
+
+        // Order: new chat → model selection → thinking selection → snapshot.
+        const newCall = mocks.startNewGeminiChat.mock.invocationCallOrder[0];
+        const modelCall = mocks.selectGeminiModel.mock.invocationCallOrder[0];
+        const thinkingCall = mocks.selectGeminiThinking.mock.invocationCallOrder[0];
+        const snapshotCall = mocks.readGeminiSnapshot.mock.invocationCallOrder[0];
+        expect(newCall).toBeLessThan(modelCall);
+        expect(modelCall).toBeLessThan(thinkingCall);
+        expect(thinkingCall).toBeLessThan(snapshotCall);
+    });
+
+    it('stops before snapshot and send when combined validation fails (invalid model)', async () => {
+        const page = createPageMock();
+        mocks.ensureGeminiPage.mockResolvedValue(undefined);
+        setupDiscoveryMocks(page);
+
+        let err;
+        try {
+            await askCommand.func(page, {
+                prompt: 'test', timeout: 20,
+                model: '99.9-nonexistent', thinking: 'standard',
+            });
+        } catch (e) { err = e; }
+
+        expect(err).toBeInstanceOf(ArgumentError);
+        expect(err.message).toContain('Unknown model');
+        // Must not proceed to snapshot, thinking selection, or send.
+        expect(mocks.selectGeminiModel).not.toHaveBeenCalled();
+        expect(mocks.selectGeminiThinking).not.toHaveBeenCalled();
+        expect(mocks.readGeminiSnapshot).not.toHaveBeenCalled();
+        expect(mocks.sendGeminiMessage).not.toHaveBeenCalled();
+    });
+
+    it('stops before snapshot and send when combined validation fails (thinking unavailable)', async () => {
+        const page = createPageMock();
+        mocks.ensureGeminiPage.mockResolvedValue(undefined);
+        setupDiscoveryWithoutThinking(page, [
+            { model: '2.5-flash-lite', thinkingValues: ['extended'] },
+            { model: '2.5-pro', thinkingValues: ['standard', 'extended'] },
+        ]);
+        mocks.selectGeminiModel.mockResolvedValueOnce(undefined);
+
+        let err;
+        try {
+            await askCommand.func(page, {
+                prompt: 'test', timeout: 20,
+                model: '2.5-flash-lite', thinking: 'standard',
+            });
+        } catch (e) { err = e; }
+
+        expect(err).toBeInstanceOf(ArgumentError);
+        expect(err.message).toContain('not available for the selected model');
+        // Must not proceed to snapshot or send.
+        expect(mocks.selectGeminiThinking).not.toHaveBeenCalled();
+        expect(mocks.readGeminiSnapshot).not.toHaveBeenCalled();
+        expect(mocks.sendGeminiMessage).not.toHaveBeenCalled();
+    });
+
+    it('does not change response extraction when model and thinking are selected', async () => {
+        vi.spyOn(Date, 'now')
+            .mockReturnValueOnce(0)
+            .mockReturnValueOnce(2000);
+        const page = createPageMock();
+        mocks.ensureGeminiPage.mockResolvedValue(undefined);
+        setupDiscoveryMocks(page);
+        mocks.selectGeminiModel.mockResolvedValueOnce(undefined);
+        setupHappyPath();
+
+        const result = await askCommand.func(page, {
+            prompt: '请只回复：OK', timeout: 20, new: 'false',
+            model: '2.5-flash', thinking: 'standard',
+        });
+
+        // Response extraction is unchanged: same prefix, same wait logic.
+        expect(mocks.readGeminiSnapshot).toHaveBeenCalledWith(page);
+        expect(mocks.waitForGeminiSubmission).toHaveBeenCalledWith(page, baseline, 20);
+        expect(mocks.waitForGeminiResponse).toHaveBeenCalledWith(page, submission, '请只回复：OK', 18);
+        expect(result).toEqual([{ response: '💬 OK' }]);
+    });
+
+    it('does not restore model or thinking after completion (combined flags)', async () => {
+        vi.spyOn(Date, 'now')
+            .mockReturnValueOnce(0)
+            .mockReturnValueOnce(2000);
+        const page = createPageMock();
+        mocks.ensureGeminiPage.mockResolvedValue(undefined);
+        setupDiscoveryMocks(page);
+        mocks.selectGeminiModel.mockResolvedValueOnce(undefined);
+        setupHappyPath();
+
+        await askCommand.func(page, {
+            prompt: 'test', timeout: 20, new: 'false',
+            model: '2.5-flash', thinking: 'standard',
+        });
+
+        // Both selectGeminiModel and selectGeminiThinking are called exactly once
+        // (for selection, not for restoration).
+        expect(mocks.selectGeminiModel).toHaveBeenCalledTimes(1);
+        expect(mocks.selectGeminiThinking).toHaveBeenCalledTimes(1);
+    });
+});