[Suggestion] readOutputLanguagePreference calls readFile on every runSideQuery invocation with no caching. The file path is static for the Config instance lifetime, and generateToolUseSummary fires on every completed tool batch — so the same small file is read from disk dozens of times per session.

Consider memoizing the result (keyed by filePath):

let cachedPreference: { filePath: string; value: string | undefined } | undefined;

async function readOutputLanguagePreference(
  config: Config,
): Promise<string | undefined> {
  const filePath = config.getOutputLanguageFilePath?.();
  if (!filePath) return undefined;
  if (cachedPreference?.filePath === filePath) return cachedPreference.value;
  try {
    const content = await readFile(filePath, 'utf8');
    const value = content.trim() || undefined;
    cachedPreference = { filePath, value };
    return value;
  } catch {
    cachedPreference = { filePath, value: undefined };
    return undefined;
  }
}

— qwen3.7-max via Qwen Code /review

Handled in 84eec74. readOutputLanguagePreference now memoizes by file path, and the new regression mutates the same output-language.md after the first side query to verify subsequent calls reuse the cached preference instead of re-reading.

[Suggestion] writeOutputLanguageFile is duplicated verbatim across 5 test files (sideQuery.test.ts, sessionRecap.test.ts, sessionTitle.test.ts, toolUseSummary.test.ts, suggestionGenerator.test.ts). Only the temp directory prefix string differs.

Consider extracting to a shared test utility:

// packages/core/src/test-utils/outputLanguage.ts
export function writeOutputLanguageFile(content: string): string {
  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'qwen-output-lang-'));
  const file = path.join(dir, 'output-language.md');
  fs.writeFileSync(file, content, 'utf8');
  return file;
}

— qwen3.7-max via Qwen Code /review

I left this one out of the focused bug fix for now. Extracting the duplicated test helper would touch several unrelated test files, while this PR's behavioral changes stay limited to side-query output-language plumbing and its direct coverage.

[Suggestion] RECAP_SYSTEM_PROMPT (line 20) and TITLE_SYSTEM_PROMPT (line 26 in sessionTitle.ts) both contain the instruction "Match the dominant language of the conversation (English or Chinese)." When respectOutputLanguagePreference: true appends a conflicting directive like "You MUST always respond in Chinese", the model receives two contradictory language instructions. The outcome is model-dependent and non-deterministic.

Consider either removing the "Match the dominant language" sentence from these prompts, or appending an explicit override (e.g., "This overrides any prior language instructions in this prompt.").

— qwen3.7-max via Qwen Code /review

Handled in 84eec74. The output-language append now includes an explicit override sentence, so a configured output-language preference supersedes earlier language-selection guidance in prompts like recap/title without editing each caller prompt separately.

[Suggestion] JSON-mode negative test coverage is asymmetric with text mode. Text mode has three negative tests (path undefined, file missing, file blank), but JSON mode has only one (file missing). Also: the test name says "path is missing" when the file at the path is missing — the text-mode tests correctly distinguish these cases. And the bare path.join(os.tmpdir(), 'qwen-side-query-missing.md') is not parallel-safe; the text-mode "file is missing" test at line ~515 correctly uses fs.mkdtempSync for isolation.

Consider adding two JSON-mode tests mirroring text mode, and using mkdtempSync for the existing one:

it('leaves JSON system instruction unchanged when output language path is undefined', async () => {
  vi.mocked(mockBaseLlmClient.generateJson).mockResolvedValue({ ok: true });
  // mockConfig already returns undefined for getOutputLanguageFilePath
  await runSideQuery<{ ok: boolean }>(mockConfig, { /* ... */ respectOutputLanguagePreference: true });
  expect(callArg.systemInstruction).toBe('custom JSON side query prompt');
});

it('leaves JSON system instruction unchanged when output language file is missing', async () => {
  vi.mocked(mockBaseLlmClient.generateJson).mockResolvedValue({ ok: true });
  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'qwen-side-query-missing-'));
  vi.mocked(mockConfig.getOutputLanguageFilePath).mockReturnValue(
    path.join(dir, 'output-language.md'),
  );
  // ...
});

it('leaves JSON system instruction unchanged when output language file is blank', async () => {
  vi.mocked(mockBaseLlmClient.generateJson).mockResolvedValue({ ok: true });
  vi.mocked(mockConfig.getOutputLanguageFilePath).mockReturnValue(
    writeOutputLanguageFile(' \n\t '),
  );
  // ...
});

— qwen3.7-max via Qwen Code /review

Added in e0c28da. JSON mode now mirrors the text-mode negative coverage: undefined output-language path, missing file using an isolated temp dir, and blank file all leave the original JSON systemInstruction unchanged.

[Suggestion] This assertion only checks that the language preference is present, but doesn't verify the original systemInstruction is preserved. Compare with existing tests in toolUseSummary.test.ts and sessionRecap.test.ts which assert both:

// Established pattern (e.g. toolUseSummary.test.ts:322-326):
expect(options.systemInstruction).toContain(TOOL_USE_SUMMARY_SYSTEM_PROMPT);
expect(options.systemInstruction).toContain('You MUST always answer in Chinese.');

If appendSystemInstructionText had a bug that replaced rather than appended, this test would still pass. Add:

— qwen3.7-max via Qwen Code /review

Added in e0c28da. The web-fetch output-language test now asserts both that the original web-fetch system instruction (Extract and summarize the requested information...) is preserved and that the configured language preference is appended.

[Suggestion] Same as web-fetch.test.ts — this only asserts the language preference is present. The established pattern in toolUseSummary.test.ts and sessionRecap.test.ts also verifies the original systemInstruction is preserved:

— qwen3.7-max via Qwen Code /review

Added in e0c28da. The subagent output-language test now follows the same pattern: it verifies the original You are an elite AI agent architect system prompt remains present and the configured language preference is appended.

[Suggestion] outputLanguagePreferenceCache is a module-level Map with no invalidation path. When a user runs /language mid-session, languageCommand.ts rewrites the file and refreshes the main conversation's system instruction — but this cache still holds the old resolved Promise. All 7 respectOutputLanguagePreference: true consumers (session title, recap, tool-use summary, follow-up suggestions, web-fetch, subagent generation, Arena) will serve the stale language rule for the remainder of the process.

The new memoization test (sideQuery.test.ts) correctly asserts this behavior, but it codifies a regression for daemon mode or any long-lived session where the user changes language.

Suggested fix: Export a clearOutputLanguagePreferenceCache() function and call it from the /language command handler (alongside the existing config.refreshHierarchicalMemory() call), or scope the cache to the Config instance lifetime rather than the module:

export function clearOutputLanguagePreferenceCache(): void {
  outputLanguagePreferenceCache.clear();
}

Then in languageCommand.ts:

import { clearOutputLanguagePreferenceCache } from '../utils/sideQuery.js';
// ...after updateOutputLanguageFile():
clearOutputLanguagePreferenceCache();

— qwen3.7-max via Qwen Code /review

Fixed in 28aee11. Side-query output-language caching now invalidates on file signature changes, and /language output ... explicitly clears the cached path after rewriting output-language.md. Added regressions for both the side-query refresh and the live /language command cache clear.

[Suggestion] Path mismatch between write target and cache invalidation target.

updateOutputLanguageFile(settingValue) writes to the global path (~/.qwen/output-language.md, hardcoded in languageUtils.ts), but clearOutputLanguagePreferenceCache(config?.getOutputLanguageFilePath?.()) clears the cache for the config's path, which may be a project-level path (<cwd>/.qwen/output-language.md). When a project-level file exists, the write modifies the global file while side queries re-read the unchanged project-level file — the user's /language command has no visible effect on side-query outputs.

Additionally, when config?.getOutputLanguageFilePath?.() returns undefined (e.g., config lacks the method), clearOutputLanguagePreferenceCache(undefined) fires the clear-all branch, wiping every cached path — including entries from other sessions in daemon mode.

Using the no-arg version clears all entries as a belt-and-suspenders approach. The stat-based invalidation in readOutputLanguagePreference handles correctness automatically on the next call, so the only cost is one extra readFile per session.

— qwen3.7-max via Qwen Code /review

Addressed in the current branch. /language output now calls clearOutputLanguagePreferenceCache() without a path after updateOutputLanguageFile(), so project/global path differences cannot leave a stale side-query language preference cached.

[Suggestion] This new public API has two branches (specific-path deletion and clear-all) but no behavioral unit tests. It is only verified via vi.fn() mock in languageCommand.test.ts, which confirms the function was called but not that it works.

Consider adding tests in sideQuery.test.ts:

1. Specific-path deletion: populate cache via runSideQuery, call clearOutputLanguagePreferenceCache(path), verify next call re-reads the file.
2. Clear-all: populate cache with entries, call clearOutputLanguagePreferenceCache(), verify all entries are removed.

Also consider adding a JSDoc note that this function is a performance hint — stat-based invalidation in readOutputLanguagePreference handles correctness automatically.

— qwen3.7-max via Qwen Code /review

Covered in the current branch. sideQuery.test.ts now exercises both cache-clear branches: specific-path deletion preserves other cached entries, and no-argument clearing refreshes all cached preferences. Verified with npm run test --workspace=packages/core -- src/utils/sideQuery.test.ts.

[Suggestion] Output language rule is appended twice to this side query. The main session's systemInstruction (extracted at line 99-105 via getGenerationConfig().systemInstruction) already embeds output-language.md content as part of userMemory (loaded through getExtensionContextFilePaths() → loadServerHierarchicalMemory()). Setting respectOutputLanguagePreference: true causes applyOutputLanguagePreference in sideQuery.ts to read the same file and append the language rule a second time.

The model receives the instruction duplicated in every summary generation — redundant tokens and a confusing artifact for anyone debugging system instructions.

Consider either:

• Removing respectOutputLanguagePreference: true here since the carried-over chatSystemInstruction already contains the rule, or
• Stripping the output-language section from chatSystemInstruction before passing it, and keeping the explicit flag.

— qwen3.7-max via Qwen Code /review

Addressed in the current branch. summaryCommand no longer sets respectOutputLanguagePreference: true for the project-summary side query because it carries over the main chat system instruction, which already includes the configured output-language rule through user memory.

[Suggestion] This test creates only a single file and verifies its cache was cleared, but does not include a negative assertion — it never checks that a different cached file's entry survived the selective clear. If clearOutputLanguagePreferenceCache(file) were accidentally changed to call .clear() instead of .delete(filePath), this test would still pass.

Consider creating a second file, caching it via runSideQuery, then after clearOutputLanguagePreferenceCache(firstFile), running a side query for the second file and asserting it still contains the original (stale) preference — proving its cache was not disturbed. This would make the two new tests properly complementary (one proves selective clear, the other proves blanket clear).

— qwen3.7-max via Qwen Code /review

Covered in the current branch. The specific-path cache test now populates two files, clears only the first path, and asserts the second cached preference survives instead of being globally cleared. Verified with npm run test --workspace=packages/core -- src/utils/sideQuery.test.ts.

[Suggestion] Transient readFile failure permanently caches undefined until the file's mtime or size changes.

When stat() succeeds but readFile() fails (EMFILE, permission flap, transient IO error), .catch(() => undefined) stores a Promise<undefined> as cached.preference with the current signature. On subsequent calls, stat() returns the same mtimeMs:size, the cache hits, and the language preference is silently lost.

— qwen3.7-max via Qwen Code /review

Addressed in the current branch. readOutputLanguagePreference() now deletes the cache entry when readFile() fails for the current signature, so transient read failures do not permanently cache undefined.

[Suggestion] The test was refactored from calling generateSessionRecap end-to-end to only testing buildSessionRecapSideQueryOptions. The old test exercised the full pipeline — config resolution, file read, system-instruction append, LLM call, extractRecap tag parsing, and the result.text / abort / error-swallowing branches. None of those paths are covered now.

Consider keeping the old integration test alongside the new unit test, or adding at least one test that calls generateSessionRecap through to the mocked LLM and asserts the final returned string (including the <recap> tag unwrap). The describe block name ('generateSessionRecap') also no longer matches what is actually tested.

— qwen3.7-max via Qwen Code /review

Addressed in the current branch. sessionRecap.test.ts now keeps an end-to-end generateSessionRecap() test that exercises the side-query call and verifies tagged <recap> extraction, alongside the focused options-builder coverage for output-language opt-in.