fix(core): address PR #3642 second-round review feedback

- shellExecutionService streaming: drop stdout/stderr buffer + outputChunks
  accumulation in streaming mode. Each decoded chunk goes straight to
  onOutputEvent and is GC-eligible immediately. Long-running background
  commands (dev servers, watchers) no longer accumulate unbounded memory
  proportional to total output. Buffered (foreground) mode is unchanged.

- shell.ts executeBackground: stripAnsi each chunk before writing to the
  output file. Dev servers / build tools spam color codes and cursor-move
  sequences that would render as garbage in the file the agent reads.

- bashesCommand: command description "List and manage" → "List background
  tasks" — current implementation only supports listing, cancellation
  follows when the unified task_stop tool from #3471 is wired in. Replace
  the hand-rolled formatRuntime helper with the shared formatDuration
  utility (uses hideTrailingZeros for parity with the previous output).

- backgroundShellRegistry: add a comment documenting the lack of an
  eviction policy as a known limitation. LRU / age-based / capped-size
  eviction (and on-disk output rotation) is left as a follow-up alongside
  the broader output-file lifecycle story.

Author: wenshao

packages/cli/src/ui/commands/bashesCommand.ts

@@ -8,15 +8,7 @@ import type { BackgroundShellEntry } from '@qwen-code/qwen-code-core';
 import type { SlashCommand } from './types.js';
 import { CommandKind } from './types.js';
 import { t } from '../../i18n/index.js';
-
-function formatRuntime(ms: number): string {
-  if (ms < 0) ms = 0;
-  const seconds = Math.floor(ms / 1000);
-  if (seconds < 60) return `${seconds}s`;
-  const minutes = Math.floor(seconds / 60);
-  const remainingSeconds = seconds % 60;
-  return `${minutes}m${remainingSeconds.toString().padStart(2, '0')}s`;
-}
+import { formatDuration } from '../utils/formatters.js';
 
 function statusLabel(entry: BackgroundShellEntry): string {
   switch (entry.status) {
@@ -37,7 +29,7 @@ export const bashesCommand: SlashCommand = {
   name: 'tasks',
   altNames: ['bashes'],
   get description() {
-    return t('List and manage background tasks');
+    return t('List background tasks');
   },
   kind: CommandKind.BUILT_IN,
   supportedModes: ['interactive', 'non_interactive', 'acp'] as const,
@@ -68,7 +60,9 @@ export const bashesCommand: SlashCommand = {
     ];
     for (const entry of entries) {
       const endTime = entry.endTime ?? now;
-      const runtime = formatRuntime(endTime - entry.startTime);
+      const runtime = formatDuration(endTime - entry.startTime, {
+        hideTrailingZeros: true,
+      });
       const pidPart = entry.pid !== undefined ? ` pid=${entry.pid}` : '';
       lines.push(
         `[${entry.shellId}] ${statusLabel(entry)}  ${runtime}${pidPart}  ${entry.command}`,

packages/core/src/services/backgroundShellRegistry.ts

@@ -48,6 +48,12 @@ export interface BackgroundShellEntry {
 }
 
 export class BackgroundShellRegistry {
+  // Entries persist for the session lifetime — no automatic eviction of
+  // terminal entries. For typical interactive sessions (tens of background
+  // shells over an hour) this is fine, but long-running sessions that spawn
+  // many short-lived background commands will see the map and the on-disk
+  // output files grow without bound. Eviction policy (LRU? age-based? cap?)
+  // is left as a follow-up alongside output-file rotation.
   private readonly entries = new Map<string, BackgroundShellEntry>();
 
   register(entry: BackgroundShellEntry): void {

packages/core/src/services/shellExecutionService.ts

@@ -418,6 +418,20 @@ export class ShellExecutionService {
             }
           }
 
+          if (streamStdout) {
+            // Streaming mode: decode + push through immediately. No buffering
+            // of stdout/stderr strings or outputChunks — long-running
+            // background commands (dev servers, watchers) would otherwise
+            // accumulate unbounded memory until exit. The consumer is
+            // expected to write each chunk to its own sink (e.g. a file).
+            const decoder = stream === 'stdout' ? stdoutDecoder : stderrDecoder;
+            const decodedChunk = decoder.decode(data, { stream: true });
+            onOutputEvent({ type: 'data', chunk: decodedChunk });
+            return;
+          }
+
+          // Buffered mode (foreground): accumulate for binary sniff +
+          // a single cleaned-blob emit at exit.
           outputChunks.push(data);
 
           if (isStreamingRawContent && sniffedBytes < MAX_SNIFF_SIZE) {
@@ -438,15 +452,6 @@ export class ShellExecutionService {
             } else {
               stderr += decodedChunk;
             }
-
-            // Push each chunk through to the consumer in streaming mode so
-            // long-running background commands (dev servers, watchers) don't
-            // accumulate output in memory until exit. Default mode (foreground)
-            // still emits the cleaned final blob in handleExit, preserving
-            // existing behavior for the in-line shell tool path.
-            if (streamStdout) {
-              onOutputEvent({ type: 'data', chunk: decodedChunk });
-            }
           }
         };
 

packages/core/src/tools/shell.ts

@@ -30,6 +30,7 @@ import type {
 } from '../services/shellExecutionService.js';
 import { ShellExecutionService } from '../services/shellExecutionService.js';
 import type { BackgroundShellEntry } from '../services/backgroundShellRegistry.js';
+import stripAnsi from 'strip-ansi';
 import { formatMemoryUsage } from '../utils/formatters.js';
 import type { AnsiOutput } from '../utils/terminalSerializer.js';
 import { isSubpaths } from '../utils/paths.js';
@@ -462,7 +463,11 @@ export class ShellToolInvocation extends BaseToolInvocation<
       cwd,
       (event: ShellOutputEvent) => {
         if (event.type === 'data' && typeof event.chunk === 'string') {
-          outputStream.write(event.chunk);
+          // Strip ANSI escape codes (color, cursor-move, clear-screen) before
+          // writing — agents read the file as plain text, and dev servers /
+          // build tools spam plenty of escape sequences that would render as
+          // garbage. Costs ~one regex per chunk; cheap relative to disk I/O.
+          outputStream.write(stripAnsi(event.chunk));
         }
         // ANSI array chunks and binary streams are not written to the output
         // file: agents read the file as plain text and binary spam would be