Thanks for the review! @DragonnZhang

• Merged main into this branch

@qwen-code /triage

Thanks for the PR! @zzhenyao

Template is mostly complete — has clear "What this PR does", "Why it is needed", "Reviewer Test Plan", and bilingual description. Minor gaps: missing the "Tested on" OS table and "Risk & Scope" section from the template, but the substantive content is solid.

On direction: this is a clean fix for a real P1 bug (#4815 — OOM from debugResponses accumulation). Removing dead code that holds references to every streaming chunk is exactly the right approach. No product-direction concerns whatsoever.

On approach: scope is perfect. The PR removes the unused debugResponses array from Turn, the orphaned extractUsageFromGeminiClient helper, and all associated test code. +2/-214 across 6 files — there's nothing to cut. I verified both symbols have zero references after the patch. The simplest possible fix.

Moving on to code review. 🔍

— Qwen Code · qwen3.7-max

Code Review

Independent proposal (before reading the diff): Remove debugResponses field from Turn, its accumulation in the streaming loop, its reset in the retry handler, and the getDebugResponses() getter. Then remove extractUsageFromGeminiClient from nonInteractiveHelpers.ts since it depends on the now-removed getter. Update tests. Nothing else needed.

Comparison with the diff: The PR matches my proposal exactly — same files, same lines, same approach. Six files touched: turn.ts (remove field, push, retry clear, getter), nonInteractiveHelpers.ts (remove function), test files (remove assertions and mocks), and a design doc (remove mention). Nothing missed, nothing extra.

No correctness bugs, no security concerns, no AGENTS.md violations. This is a clean dead-code removal with zero residual references confirmed by git grep.

Build & Tests

$ npm run build
✓ build succeeded (0 errors)

$ npm run typecheck
✓ tsc --noEmit passed for all packages

$ cd packages/core && npx vitest run src/core/turn.test.ts
✓ 23 tests passed

$ cd packages/cli && npx vitest run src/utils/nonInteractiveHelpers.test.ts
✓ 52 tests passed

$ cd packages/cli && npx vitest run src/nonInteractiveCli.test.ts
✓ 45 tests passed (1 skipped, pre-existing)

Real-Scenario Verification

This PR removes dead code that causes OOM — the bug manifests only in long-running sessions (minutes to hours of streaming). A quick tmux prompt can't reproduce 8GB heap exhaustion, but I verified the core claim: both symbols are completely absent from the PR's built output.

$ node .qwen/worktrees/triage/dist/cli.js --version
0.17.1

$ grep -c 'debugResponses' .qwen/worktrees/triage/dist/cli.js
0
$ grep -c 'extractUsageFromGeminiClient' .qwen/worktrees/triage/dist/cli.js
0

Before (installed v0.18.0):

$ grep -c 'debugResponses' /usr/local/lib/node_modules/@qwen-code/qwen-code/chunks/chunk-IWAYOW5Q.js
4

After (this PR's bundle):

$ grep -c 'debugResponses' dist/cli.js
0

Source-level verification on main branch (before PR):

$ git show main:packages/core/src/core/turn.ts | grep -n 'debugResponses'
291:  private debugResponses: GenerateContentResponse[] = [];
331:          this.debugResponses = [];
358:        this.debugResponses.push(resp);
483:    return this.debugResponses;

$ git show main:packages/cli/src/utils/nonInteractiveHelpers.ts | grep -n 'extractUsageFromGeminiClient'
105:export function extractUsageFromGeminiClient(

Source-level verification on PR branch (after):

$ git grep 'debugResponses' pr-4982
(no matches)

$ git grep 'extractUsageFromGeminiClient' pr-4982
(no matches)

Both symbols fully removed — from source, tests, and the production bundle.

— Qwen Code · qwen3.7-max

Final Assessment

This PR is exactly what it should be: a surgical removal of dead code that causes a P1 OOM bug. The motivation is clear (users hitting 8GB heap exhaustion in long sessions), the fix is minimal (+2/-214, 6 files), and the execution is clean.

My independent proposal matched the diff line-for-line. There's nothing to simplify further — you can't make "delete unused code" any simpler.

Build, typecheck, and all 120 tests across the three affected test files pass. Both symbols confirmed absent from the production bundle. The source-level git grep verification on the PR branch returns zero matches for both debugResponses and extractUsageFromGeminiClient.

The PR description is one of the better ones I've seen — it explains both the root cause (chunk accumulation in the Turn object's lifetime) and the two specific OOM scenarios (non-goal mode thinking loops, goal mode nested turns). The bilingual format and reviewer test plan make review straightforward.

Approving. ✅

— Qwen Code · qwen3.7-max

Local verification report (maintainer)

Verified this PR locally with real runs, not just the test suite. Since the PR's merge-base is ~50 commits behind main, all checks below were run on the merge result of this PR + latest origin/main (92c4a82) to rule out semantic conflicts that GitHub's MERGEABLE flag cannot catch.

1. Dead-code claim — confirmed, plus one stronger finding

• On latest main, the only references to debugResponses / getDebugResponses / extractUsageFromGeminiClient are the definitions themselves and their test files. No production reader exists.
• After merging this PR into latest main: whole-repo case-insensitive grep finds zero remaining references (all file types, not just .ts).
• Stronger than "unused": extractUsageFromGeminiClient is not just unused — it is a no-op. It probes geminiClient.getChat().getDebugResponses(), but on current main the GeminiChat class has no getDebugResponses method at all (only Turn has one, and the helper never touches Turn). The helper can only ever return undefined, and the mock in nonInteractiveCli.test.ts was mocking a method that doesn't exist on the real class. The non-interactive usage path goes through computeUsageFromMetrics (4 call sites in nonInteractiveCli.ts), exactly as the PR description says.
• One note for the record: Turn is re-exported from core's public index.ts (export * from './core/turn.js'), so removing getDebugResponses() technically shrinks the public surface of @qwen-code/qwen-code-core for external consumers. In-repo impact is zero — nothing imports it anywhere in the monorepo.

2. Build / typecheck / tests (merged tree)

On the cli full-suite failures: all 26 are pre-existing on latest main or load-induced flakes, in files that import nothing this PR touches (AuthDialog, InputPrompt, useAtCompletion, server, …).

• AuthDialog.test.tsx fails identically on pure origin/main and on the merged tree (isolation run: 11 failed / 13 passed on both) — pre-existing on latest main in this environment (vi.waitFor timeouts).
• useAtCompletion.test.ts fails on both trees as well.
• The other 7 files only fail under CPU contention (two full suites ran concurrently) and pass when re-run on an idle machine; the failing subset also varies between back-to-back runs on the same tree, which is the signature of timing flakes, not a regression.

3. Real-run smoke tests (bundled CLI from the merged tree, driven via tmux)

• Non-interactive (-p "What is 2+2? ..." --output-format json): exit 0, correct answer, and the final result event carries real usage — {"input_tokens":19365,"output_tokens":9,"total_tokens":19374} — produced by computeUsageFromMetrics. The removed helper is demonstrably not part of this path.
• Interactive (tmux): multi-chunk streaming response renders fully; a tool-call turn (ReadFile) executes and returns correct content; /stats reports correct token accounting (58.3k input, 96.9% cached). Turn.run behaves identically without debugResponses.

4. Memory-retention benchmark — the OOM claim holds empirically

Drove Turn.run directly (mocked chat.sendMessageStream) with 2000 chunks carrying ~63 MB of unique text, measured with node --expose-gc on both builds:

Both builds emitted an identical event stream (2001 events) — behavior parity. A WeakRef probe confirms the mechanism: on main, chunk objects are uncollectable for the entire Turn lifetime and become collectable the moment the Turn is released — exactly the retention pattern described in the PR (long thinking loops within one turn; nested goal-mode turns held until the outer call completes). (The 469 MB > 63 MB delta is benchmark string-rope overhead; production chunks are flat JSON.parse strings, so real retention ≈ payload + object overhead — still unbounded and proportional to chunk count.)

Verdict

✅ Safe to merge. Dead code with zero references after merging into latest main; build, typecheck, all targeted tests, and the full core suite are green (the cli suite's 26 failures are pre-existing on pure main or load-induced flakes — none attributable to this PR); real CLI behavior is intact in both modes; and the memory claim is reproducible, not just theoretical.