fix(gemini): stabilize ask reply state handling

src/clis/gemini/ask.test.ts

@@ -0,0 +1,116 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import type { IPage } from '../../types.js';
+
+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' as const,
+};
+
+const mocks = vi.hoisted(() => ({
+  readGeminiSnapshot: vi.fn(),
+  sendGeminiMessage: vi.fn(),
+  startNewGeminiChat: vi.fn(),
+  waitForGeminiSubmission: vi.fn(),
+  waitForGeminiResponse: vi.fn(),
+}));
+
+vi.mock('./utils.js', async () => {
+  const actual = await vi.importActual<typeof import('./utils.js')>('./utils.js');
+  return {
+    ...actual,
+    readGeminiSnapshot: mocks.readGeminiSnapshot,
+    sendGeminiMessage: mocks.sendGeminiMessage,
+    startNewGeminiChat: mocks.startNewGeminiChat,
+    waitForGeminiSubmission: mocks.waitForGeminiSubmission,
+    waitForGeminiResponse: mocks.waitForGeminiResponse,
+  };
+});
+
+import { askCommand } from './ask.js';
+
+function createPageMock(): IPage {
+  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),
+  } as unknown as IPage;
+}
+
+describe('gemini ask orchestration', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  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.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.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);
+  });
+});

src/clis/gemini/ask.ts

@@ -1,6 +1,6 @@
 import { cli, Strategy } from '../../registry.js';
 import type { IPage } from '../../types.js';
-import { GEMINI_DOMAIN, getGeminiTranscriptLines, sendGeminiMessage, startNewGeminiChat, waitForGeminiResponse } from './utils.js';
+import { GEMINI_DOMAIN, readGeminiSnapshot, sendGeminiMessage, startNewGeminiChat, waitForGeminiResponse, waitForGeminiSubmission } from './utils.js';
 
 function normalizeBooleanFlag(value: unknown): boolean {
   if (typeof value === 'boolean') return value;
@@ -33,9 +33,16 @@ export const askCommand = cli({
 
     if (startFresh) await startNewGeminiChat(page);
 
-    const beforeLines = await getGeminiTranscriptLines(page);
+    const before = await readGeminiSnapshot(page);
     await sendGeminiMessage(page, prompt);
-    const response = await waitForGeminiResponse(page, beforeLines, prompt, timeout);
+    const submissionStartedAt = Date.now();
+    const submitted = await waitForGeminiSubmission(page, before, timeout);
+    if (!submitted) {
+      return [{ response: `💬 ${NO_RESPONSE_PREFIX} No Gemini response within ${timeout}s.` }];
+    }
+
+    const remainingTimeoutSeconds = Math.max(0, timeout - Math.ceil((Date.now() - submissionStartedAt) / 1000));
+    const response = await waitForGeminiResponse(page, submitted, prompt, remainingTimeoutSeconds);
 
     if (!response) {
       return [{ response: `💬 ${NO_RESPONSE_PREFIX} No Gemini response within ${timeout}s.` }];