feat(daemon): add POST /session/:id/language for runtime language switching

packages/acp-bridge/src/bridge.ts

@@ -3143,6 +3143,58 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge {
       return response;
     },
 
+    async setSessionLanguage(sessionId, params, context) {
+      const entry = byId.get(sessionId);
+      if (!entry) throw new SessionNotFoundError(sessionId);
+      const info = channelInfoForEntry(entry);
+      if (!info || info.isDying) throw new SessionNotFoundError(sessionId);
+      const originatorClientId = resolveTrustedClientId(
+        entry,
+        context?.clientId,
+      );
+
+      const result = (await Promise.race([
+        withTimeout(
+          entry.connection.extMethod(
+            SERVE_CONTROL_EXT_METHODS.sessionLanguage,
+            {
+              sessionId,
+              language: params.language,
+              syncOutputLanguage: params.syncOutputLanguage,
+            },
+          ),
+          initTimeoutMs,
+          SERVE_CONTROL_EXT_METHODS.sessionLanguage,
+        ),
+        getTransportClosedReject(entry),
+      ])) as {
+        language: string;
+        outputLanguage: string | null;
+        refreshed: boolean;
+      };
+
+      try {
+        entry.events.publish({
+          type: 'language_changed',
+          data: {
+            sessionId: entry.sessionId,
+            language: result.language,
+            outputLanguage: result.outputLanguage ?? null,
+            refreshed: result.refreshed ?? false,
+          },
+          ...(originatorClientId ? { originatorClientId } : {}),
+        });
+      } catch {
+        /* bus closed */
+      }
+
+      return {
+        language: result.language,
+        outputLanguage: result.outputLanguage ?? null,
+        refreshed: result.refreshed ?? false,
+      };
+    },
+
     async setSessionApprovalMode(sessionId, mode, opts, context) {
       // Forwards through `qwen/control/session/approval_mode` so the
       // change lands inside the ACP child's own `Config` (per-session
@@ -3532,8 +3584,7 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge {
         const data = (err as { data?: unknown })?.data;
         if (data && typeof data === 'object' && 'errorKind' in data) {
           const kind = (data as { errorKind: string }).errorKind;
-          const msg =
-            (err as { message?: string })?.message ?? 'Rewind failed';
+          const msg = (err as { message?: string })?.message ?? 'Rewind failed';
           if (kind === 'session_busy') {
             throw new SessionBusyError(sessionId, msg);
           }
@@ -3544,12 +3595,9 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge {
         throw err;
       }
 
-      const targetTurnIndex =
-        (response['targetTurnIndex'] as number) ?? 0;
-      const filesChanged =
-        (response['filesChanged'] as string[]) ?? [];
-      const filesFailed =
-        (response['filesFailed'] as string[]) ?? [];
+      const targetTurnIndex = (response['targetTurnIndex'] as number) ?? 0;
+      const filesChanged = (response['filesChanged'] as string[]) ?? [];
+      const filesFailed = (response['filesFailed'] as string[]) ?? [];
 
       try {
         entry.events.publish({

packages/acp-bridge/src/bridgeTypes.ts

@@ -373,6 +373,22 @@ export interface AcpSessionBridge {
     context?: BridgeClientRequestContext,
   ): Promise<SetSessionModelResponse>;
 
+  /**
+   * Switch UI language and optionally LLM output language for a live
+   * session, then broadcast a `language_changed` event.  When
+   * `syncOutputLanguage` is true the handler also refreshes every
+   * session's system prompt so the next LLM call uses the new language.
+   */
+  setSessionLanguage(
+    sessionId: string,
+    params: { language: string; syncOutputLanguage: boolean },
+    context?: BridgeClientRequestContext,
+  ): Promise<{
+    language: string;
+    outputLanguage: string | null;
+    refreshed: boolean;
+  }>;
+
   /**
    * Change the approval mode of a live session and broadcast an
    * `approval_mode_changed` event. `opts.persist === true` also writes

packages/acp-bridge/src/status.ts

@@ -126,6 +126,7 @@ export const SERVE_CONTROL_EXT_METHODS = {
   sessionRecap: 'qwen/control/session/recap',
   sessionBtw: 'qwen/control/session/btw',
   sessionShellHistory: 'qwen/control/session/shell_history',
+  sessionLanguage: 'qwen/control/session/language',
   sessionRewind: 'qwen/control/session/rewind',
   workspaceMcpRestart: 'qwen/control/workspace/mcp/restart',
   workspaceMcpManage: 'qwen/control/workspace/mcp/manage',

packages/cli/src/acp-integration/acpAgent.ts

@@ -110,6 +110,17 @@ import {
 import { runWithAcpRuntimeOutputDir } from './runtimeOutputDirContext.js';
 import { runExitCleanup } from '../utils/cleanup.js';
 import { appEvents, AppEvent } from '../utils/events.js';
+import {
+  setLanguageAsync,
+  getCurrentLanguage,
+  SUPPORTED_LANGUAGES,
+} from '../i18n/index.js';
+import {
+  resolveOutputLanguage,
+  updateOutputLanguageFile,
+  isAutoLanguage,
+  OUTPUT_LANGUAGE_AUTO,
+} from '../utils/languageUtils.js';
 import {
   ACP_PREFLIGHT_KINDS,
   STATUS_SCHEMA_VERSION,
@@ -2739,6 +2750,102 @@ class QwenAgent implements Agent {
         const current = config.getApprovalMode();
         return { previous, current };
       }
+      case SERVE_CONTROL_EXT_METHODS.sessionLanguage: {
+        const sessionId = params['sessionId'];
+        const language = params['language'];
+        const syncOutputLanguage = params['syncOutputLanguage'] === true;
+
+        if (typeof sessionId !== 'string' || sessionId.length === 0) {
+          throw RequestError.invalidParams(
+            undefined,
+            'Invalid or missing sessionId',
+          );
+        }
+        const allowedLanguages = [
+          ...SUPPORTED_LANGUAGES.map((l) => l.code),
+          'auto',
+        ];
+        if (
+          typeof language !== 'string' ||
+          !allowedLanguages.includes(language)
+        ) {
+          throw RequestError.invalidParams(
+            undefined,
+            `Invalid language; must be one of: ${allowedLanguages.join(', ')}`,
+          );
+        }
+
+        this.sessionOrThrow(sessionId);
+
+        try {
+          await setLanguageAsync(language);
+        } catch (err) {
+          debugLogger.warn('setLanguageAsync failed:', err);
+          throw new RequestError(
+            -32603,
+            `Failed to switch UI language: ${err instanceof Error ? err.message : String(err)}`,
+          );
+        }
+
+        const resolvedLanguage = getCurrentLanguage();
+
+        try {
+          this.settings.setValue(
+            SettingScope.User,
+            'general.language',
+            language,
+          );
+        } catch (err) {
+          debugLogger.warn('Failed to persist UI language setting:', err);
+        }
+
+        let outputLanguage: string | null = null;
+        let refreshed = false;
+
+        if (syncOutputLanguage) {
+          const resolved = resolveOutputLanguage(language);
+          const settingValue = isAutoLanguage(language)
+            ? OUTPUT_LANGUAGE_AUTO
+            : resolved;
+
+          try {
+            updateOutputLanguageFile(settingValue);
+          } catch (err) {
+            debugLogger.warn('Failed to write output-language.md:', err);
+          }
+
+          try {
+            this.settings.setValue(
+              SettingScope.User,
+              'general.outputLanguage',
+              settingValue,
+            );
+          } catch (err) {
+            debugLogger.warn('Failed to persist output language setting:', err);
+          }
+
+          const allSessions = [...this.sessions.values()];
+          const results = await Promise.allSettled(
+            allSessions.map(async (s) => {
+              const cfg = s.getConfig();
+              await cfg.refreshHierarchicalMemory();
+              await cfg.getGeminiClient()?.refreshSystemInstruction();
+            }),
+          );
+          const failedCount = results.filter(
+            (r) => r.status === 'rejected',
+          ).length;
+          if (failedCount > 0) {
+            debugLogger.warn(
+              `Language refresh failed for ${failedCount}/${results.length} session(s)`,
+            );
+          }
+          refreshed = failedCount < results.length;
+          outputLanguage = resolved;
+        }
+
+        return { language: resolvedLanguage, outputLanguage, refreshed };
+      }
       case SERVE_CONTROL_EXT_METHODS.sessionRecap: {
         // Generate a one-sentence "where did I leave off" summary.
         // Best-effort: returns `null` on short history or model failure.