perf(cli): defer startup prefetch tasks

packages/cli/src/config/config.test.ts

@@ -31,6 +31,7 @@ const mockSessionServiceInstance = vi.hoisted(() => ({
 const mockSessionServiceCtor = vi.hoisted(() =>
   vi.fn(() => mockSessionServiceInstance),
 );
+const mockConfigConstructorParams = vi.hoisted(() => vi.fn());
 
 vi.mock('../utils/stdioHelpers.js', () => ({
   writeStderrLine: mockWriteStderrLine,
@@ -160,8 +161,15 @@ vi.mock('@qwen-code/qwen-code-core', async (importOriginal) => {
   SkillManagerMock.prototype.listSkills = vi.fn().mockResolvedValue([]);
   SkillManagerMock.prototype.addChangeListener = vi.fn();
   SkillManagerMock.prototype.removeChangeListener = vi.fn();
+  class ConfigWithParamCapture extends actualServer.Config {
+    constructor(...args: ConstructorParameters<typeof actualServer.Config>) {
+      mockConfigConstructorParams(args[0]);
+      super(...args);
+    }
+  }
   return {
     ...actualServer,
+    Config: ConfigWithParamCapture,
     NativeLspService: vi
       .fn()
       .mockImplementation(() => createNativeLspServiceInstance()),
@@ -1541,6 +1549,7 @@ describe('loadCliConfig', () => {
 
 describe('loadCliConfig telemetry', () => {
   const originalArgv = process.argv;
+  const originalIsTTY = process.stdin.isTTY;
 
   beforeEach(() => {
     vi.resetAllMocks();
@@ -1550,6 +1559,7 @@ describe('loadCliConfig telemetry', () => {
 
   afterEach(() => {
     process.argv = originalArgv;
+    process.stdin.isTTY = originalIsTTY;
     vi.unstubAllEnvs();
     vi.restoreAllMocks();
   });
@@ -1570,6 +1580,41 @@ describe('loadCliConfig telemetry', () => {
     expect(config.getTelemetryEnabled()).toBe(true);
   });
 
+  it('should initialize telemetry before prompt-interactive startup', async () => {
+    process.argv = [
+      'node',
+      'script.js',
+      '-i',
+      'hello from prompt-interactive',
+      '--telemetry',
+    ];
+    const argv = await parseArguments();
+
+    await loadCliConfig({}, argv);
+
+    expect(mockConfigConstructorParams).toHaveBeenCalledWith(
+      expect.objectContaining({
+        question: 'hello from prompt-interactive',
+        deferTelemetryInitialization: false,
+      }),
+    );
+  });
+
+  it('should defer telemetry for ordinary interactive startup', async () => {
+    process.argv = ['node', 'script.js', '--telemetry'];
+    process.stdin.isTTY = true;
+    const argv = await parseArguments();
+
+    await loadCliConfig({}, argv);
+
+    expect(mockConfigConstructorParams).toHaveBeenCalledWith(
+      expect.objectContaining({
+        question: '',
+        deferTelemetryInitialization: true,
+      }),
+    );
+  });
+
   it('should set telemetry to false when --no-telemetry flag is present', async () => {
     process.argv = ['node', 'script.js', '--no-telemetry'];
     const argv = await parseArguments();

packages/cli/src/config/config.ts

@@ -2050,6 +2050,9 @@ export async function loadCliConfig(
     showResponseTokensPerSecond:
       settings.ui?.showResponseTokensPerSecond === true,
     telemetry: telemetrySettings,
+    // Prompt-interactive (`qwen -i "prompt"`) auto-submits its first prompt,
+    // so telemetry must be ready before that request is sent.
+    deferTelemetryInitialization: interactive && !isAcpMode && !question,
     outboundCorrelation: settings.outboundCorrelation,
     usageStatisticsEnabled: settings.privacy?.usageStatisticsEnabled ?? true,
     clearContextOnIdle: settings.context?.clearContextOnIdle,

packages/cli/src/core/initializer.test.ts

@@ -5,7 +5,7 @@
  */
 
 import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { initializeApp } from './initializer.js';
+import { connectIdeForStartup, initializeApp } from './initializer.js';
 
 const mockPerformInitialAuth = vi.fn();
 const mockValidateTheme = vi.fn();
@@ -164,7 +164,7 @@ describe('initializeApp', () => {
     expect(result.shouldOpenAuthDialog).toBe(false);
   });
 
-  it('should connect to IDE when in IDE mode', async () => {
+  it('should connect to IDE by default when in IDE mode', async () => {
     mockConfig.getIdeMode.mockReturnValue(true);
 
     await initializeApp(mockConfig as never, mockSettings as never);
@@ -174,6 +174,28 @@ describe('initializeApp', () => {
     expect(mockLogIdeConnection).toHaveBeenCalled();
   });
 
+  it('should not connect to IDE when deferred', async () => {
+    mockConfig.getIdeMode.mockReturnValue(true);
+
+    await initializeApp(mockConfig as never, mockSettings as never, {
+      deferIdeConnection: true,
+    });
+
+    expect(mockGetInstance).not.toHaveBeenCalled();
+    expect(mockConnect).not.toHaveBeenCalled();
+    expect(mockLogIdeConnection).not.toHaveBeenCalled();
+  });
+
+  it('should connect to IDE through startup helper', async () => {
+    mockConfig.getIdeMode.mockReturnValue(true);
+
+    await connectIdeForStartup(mockConfig as never);
+
+    expect(mockGetInstance).toHaveBeenCalled();
+    expect(mockConnect).toHaveBeenCalled();
+    expect(mockLogIdeConnection).toHaveBeenCalled();
+  });
+
   it('should not connect to IDE when not in IDE mode', async () => {
     mockConfig.getIdeMode.mockReturnValue(false);
 

packages/cli/src/core/initializer.ts

@@ -14,10 +14,7 @@ import {
 import { type LoadedSettings } from '../config/settings.js';
 import { performInitialAuth } from './auth.js';
 import { validateTheme } from './theme.js';
-import {
-  initializeI18n,
-  resolveLanguageSetting,
-} from '../i18n/index.js';
+import { initializeI18n, resolveLanguageSetting } from '../i18n/index.js';
 
 export interface InitializationResult {
   authError: string | null;
@@ -26,6 +23,30 @@ export interface InitializationResult {
   geminiMdFileCount: number;
 }
 
+export interface InitializeAppOptions {
+  /**
+   * When true, skip the awaited IDE connection inside initializeApp().
+   * Ordinary interactive TUI startup uses this so IDE IPC can run after first
+   * paint; non-TUI paths leave it false so the first request keeps IDE context.
+   */
+  deferIdeConnection?: boolean;
+}
+
+/**
+ * Establishes the startup IDE connection and records the connection telemetry.
+ *
+ * Callers choose whether to await this on the startup critical path. Headless,
+ * stream-json, and ACP/Zed await it before their first request; ordinary TUI
+ * startup schedules it post-render through startup prefetch.
+ */
+export async function connectIdeForStartup(config: Config): Promise<void> {
+  if (!config.getIdeMode()) return;
+
+  const ideClient = await IdeClient.getInstance();
+  await ideClient.connect();
+  logIdeConnection(config, new IdeConnectionEvent(IdeConnectionType.START));
+}
+
 /**
  * Orchestrates the application's startup initialization.
  * This runs BEFORE the React UI is rendered.
@@ -36,6 +57,7 @@ export interface InitializationResult {
 export async function initializeApp(
   config: Config,
   settings: LoadedSettings,
+  options: InitializeAppOptions = {},
 ): Promise<InitializationResult> {
   // Initialize i18n system
   await initializeI18n(
@@ -52,10 +74,8 @@ export async function initializeApp(
   const shouldOpenAuthDialog =
     !config.getModelsConfig().wasAuthTypeExplicitlyProvided() || !!authError;
 
-  if (config.getIdeMode()) {
-    const ideClient = await IdeClient.getInstance();
-    await ideClient.connect();
-    logIdeConnection(config, new IdeConnectionEvent(IdeConnectionType.START));
+  if (!options.deferIdeConnection) {
+    await connectIdeForStartup(config);
   }
 
   return {