@@ -960,7 +960,7 @@ Gets the debuggee's output (stdout/stderr/console) captured for a session. Outpu
 
 **Notes:**
 - The buffer holds the last 1000 entries per launch; older entries are evicted and counted in `dropped`. Individual entries longer than 8192 characters are cut and flagged `"truncated": true`.
-- Adapter-internal `telemetry` events are filtered out at capture time; all other categories (`stdout`, `stderr`, `console`, `important`, ...) are kept. Adapters that omit a category default to `console`.
+- Adapter-internal `telemetry` events are filtered out at capture time, as are output events an adapter policy declares to be pure adapter noise — e.g. LLDB's harmless DWARF-parser error spew on MinGW-built rust/cpp binaries (issue #361); suppressed lines remain visible in debug logs. All other categories (`stdout`, `stderr`, `console`, `important`, ...) are kept. Adapters that omit a category default to `console`.
 - Works while the program is running and after it finishes — output stays readable until `close_debug_session`. Re-launching a session starts a fresh buffer (seq restarts at 1).
 - `hasMore: true` means more entries matched than `limit` allowed; call again with `since: nextSince`.
 - Incremental polling recipe: call once, remember `nextSince`, and pass it as `since` on the next call — you'll only ever see new output.
 
@@ -28,7 +28,8 @@ import {
   isLldbConnected,
   getLldbDapClientBehavior,
   isLldbInternalFrame,
-  filterLldbStackFrames
+  filterLldbStackFrames,
+  lldbShouldSuppressOutputEvent
 } from './lldb-policy-shared.js';
 
 export const CppAdapterPolicy: AdapterPolicy = {
@@ -47,6 +48,7 @@ export const CppAdapterPolicy: AdapterPolicy = {
   },
 
   normalizeStopReason: normalizeLldbStopReason,
+  shouldSuppressOutputEvent: lldbShouldSuppressOutputEvent,
 
   /**
    * Hide LLDB-synthesized symbols and libc/runtime plumbing from stack
 
@@ -21,7 +21,8 @@ import {
   isLldbConnected,
   getLldbDapClientBehavior,
   isLldbInternalFrame,
-  filterLldbStackFrames
+  filterLldbStackFrames,
+  lldbShouldSuppressOutputEvent
 } from './lldb-policy-shared.js';
 
 export const RustAdapterPolicy: AdapterPolicy = {
@@ -55,6 +56,7 @@ export const RustAdapterPolicy: AdapterPolicy = {
    * LLDB-backed policy; see normalizeLldbStopReason for the full rules.
    */
   normalizeStopReason: normalizeLldbStopReason,
+  shouldSuppressOutputEvent: lldbShouldSuppressOutputEvent,
 
   /**
    * Hide LLDB-synthesized symbols and libc/runtime plumbing from stack
 
@@ -166,6 +166,20 @@ export interface AdapterPolicy {
    */
   isInternalFrame?(frame: StackFrame): boolean;
 
+  /**
+   * Return true to drop a DAP 'output' event that is known adapter-internal
+   * noise, not debuggee output (issue #361 — e.g. LLDB's DWARF-parsing
+   * error spew on MinGW binaries). Consulted by the session manager's output
+   * capture AFTER the standard 'telemetry' category drop; suppressed events
+   * are still logged at debug level. Optional — absent means capture
+   * everything. Implementations must be conservative: when in doubt, keep
+   * the output.
+   *
+   * @param category The DAP output category ('stdout', 'stderr', 'console', ...)
+   * @param text The event's output text (may span multiple lines)
+   */
+  shouldSuppressOutputEvent?(category: string, text: string): boolean;
+
   /**
    * Normalize an adapter-specific DAP stop reason into a canonical reason
    * ('pause', 'breakpoint', 'step', 'exception', ...). Some adapters report
 
@@ -266,6 +266,52 @@ export function filterLldbStackFrames(frames: StackFrame[], includeInternals: bo
   return frames.filter((frame) => !isLldbInternalFrame(frame));
 }
 
+/**
+ * LLDB's own DWARF-parser diagnostics (issue #361). MinGW/g++-generated
+ * debug info routinely trips LLDB's DWARF parser into printing multi-line
+ * "error: ..." spew on stderr ("DIE has DW_AT_ranges ... range extraction
+ * failed", "DW_TAG_member '...' refers to type ... which extends beyond the
+ * bounds ..."), even though debugging then works perfectly. These are
+ * adapter internals, not debuggee output — filter them out of the captured
+ * output buffer the same way 'telemetry' events are.
+ *
+ * Patterns are anchored on DWARF-specific tokens (DIE / DW_AT_ / DW_TAG_ /
+ * "please file a bug") so genuine program stderr containing the word
+ * "error:" is never eaten.
+ */
+const LLDB_DWARF_NOISE_PATTERNS: RegExp[] = [
+  // "error: <module> [0x...]: DIE has DW_AT_ranges(...) attribute, but ..."
+  /^error:\s+.*\bDIE\b.*\bDW_AT_/,
+  // "error: <module> 0x...: DW_TAG_member '...' refers to type ... which extends beyond the bounds ..."
+  /^error:\s+.*\bDW_TAG_\w+\b/,
+  // Generic DWARF diagnostic shape: "error: <module> 0x...: ... DW_AT_..."
+  /^error:\s+\S+.*\bDW_(AT|TAG|FORM)_\w+/,
+  // Continuation lines of the multi-line DIE diagnostic (LLDB wraps it; the
+  // pieces can arrive trimmed or even as separate line-buffered events)
+  /\bplease file a bug and attach the file\b/,
+  /^start of this error message$/,
+  /\brange extraction failed\b/,
+  /\binvalid range list offset\b/,
+  /\bextends beyond the bounds of 0x[0-9a-f]+\b/
+];
+
+/**
+ * Suppress a DAP output event when it is purely LLDB DWARF-parser noise.
+ * Multi-line events are dropped only when EVERY non-empty line matches a
+ * noise pattern — mixed content always passes through untouched (never
+ * partially rewritten).
+ */
+export function lldbShouldSuppressOutputEvent(category: string, text: string): boolean {
+  if (category !== 'stderr' && category !== 'console') {
+    return false;
+  }
+  const lines = text.split('\n').map((line) => line.trim()).filter((line) => line.length > 0);
+  if (lines.length === 0) {
+    return false;
+  }
+  return lines.every((line) => LLDB_DWARF_NOISE_PATTERNS.some((pattern) => pattern.test(line)));
+}
+
 /**
  * Validate that a CodeLLDB binary exists and answers --version with output
  * containing 'codelldb'.
 
@@ -0,0 +1,53 @@
+/**
+ * LLDB DWARF-parser noise suppression (issue #361).
+ */
+import { describe, it, expect } from 'vitest';
+import { lldbShouldSuppressOutputEvent } from '../../src/interfaces/lldb-policy-shared.js';
+import { CppAdapterPolicy } from '../../src/interfaces/adapter-policy-cpp.js';
+import { RustAdapterPolicy } from '../../src/interfaces/adapter-policy-rust.js';
+
+const DIE_ERROR_MULTILINE =
+  "error: hello_world.exe [0x0000000000002293]: DIE has DW_AT_ranges(DW_FORM_sec_offset 0x000000000000000c) attribute,\n" +
+  '  but range extraction failed (invalid range list offset 0xc), please file a bug and attach the file at the\n' +
+  '  start of this error message\n';
+
+const MEMBER_ERROR =
+  "error: hello_world.exe 0x00002b54: DW_TAG_member '_M_local_buf' refers to type 0x0000000000010ac0 which extends beyond the bounds of 0x00002b4b\n";
+
+describe('lldbShouldSuppressOutputEvent', () => {
+  it('suppresses the multi-line DIE/DW_AT_ranges diagnostic', () => {
+    expect(lldbShouldSuppressOutputEvent('stderr', DIE_ERROR_MULTILINE)).toBe(true);
+  });
+
+  it('suppresses the DW_TAG_member bounds diagnostic', () => {
+    expect(lldbShouldSuppressOutputEvent('stderr', MEMBER_ERROR)).toBe(true);
+  });
+
+  it('suppresses line-buffered fragments of the DIE diagnostic delivered as separate events', () => {
+    for (const line of DIE_ERROR_MULTILINE.split('\n').filter(l => l.trim())) {
+      expect(lldbShouldSuppressOutputEvent('stderr', line + '\n'), line).toBe(true);
+    }
+  });
+
+  it('keeps genuine program stderr, even when it contains the word error:', () => {
+    expect(lldbShouldSuppressOutputEvent('stderr', 'error: could not open config file\n')).toBe(false);
+    expect(lldbShouldSuppressOutputEvent('stderr', 'panicked at src/main.rs:10\n')).toBe(false);
+  });
+
+  it('keeps mixed events where any line is not noise (never partially rewrites)', () => {
+    const mixed = MEMBER_ERROR + 'real program output\n';
+    expect(lldbShouldSuppressOutputEvent('stderr', mixed)).toBe(false);
+  });
+
+  it('never suppresses stdout or empty events', () => {
+    expect(lldbShouldSuppressOutputEvent('stdout', MEMBER_ERROR)).toBe(false);
+    expect(lldbShouldSuppressOutputEvent('stderr', '\n')).toBe(false);
+    expect(lldbShouldSuppressOutputEvent('stderr', '')).toBe(false);
+  });
+
+  it('is wired into both the rust and cpp policies', () => {
+    expect(RustAdapterPolicy.shouldSuppressOutputEvent?.('stderr', MEMBER_ERROR)).toBe(true);
+    expect(CppAdapterPolicy.shouldSuppressOutputEvent?.('stderr', MEMBER_ERROR)).toBe(true);
+    expect(RustAdapterPolicy.shouldSuppressOutputEvent?.('stdout', 'hello\n')).toBe(false);
+  });
+});
@@ -147,6 +147,16 @@ export class ChildSessionManager extends EventEmitter {
   // (correlation/bind window) cannot be overtaken by later events
   private childEventChain: Promise<void> = Promise.resolve();
 
+  /**
+   * Resolves when every child event enqueued so far has been forwarded
+   * (issue #366): output events ride the childEventChain when the CDP bridge
+   * is active, so a terminal event must not be forwarded upstream until the
+   * chain has drained or queued output is silently dropped at teardown.
+   */
+  flushEvents(): Promise<void> {
+    return this.childEventChain;
+  }
+
   constructor(options: ChildSessionOptions) {
     super();
     this.policy = options.policy;
 
@@ -173,6 +173,12 @@ export interface IDapClient {
    * MinimalDapClient (js-debug child sessions) implements it.
    */
   setExceptionBreakMode?(mode: 'uncaught' | 'all' | 'none'): void;
+  /**
+   * Resolves once all child-session events enqueued so far (output included)
+   * have been forwarded (issue #366). Optional: only MinimalDapClient
+   * (js-debug child sessions) implements it; absent means nothing to flush.
+   */
+  flushChildEvents?(): Promise<void>;
 }
 
 /**
 
@@ -733,6 +733,7 @@ export class DapProxyWorker {
         this.exitedEventSeen = true;
         return this.enqueueTerminalSignal('exited', async () => {
           await this.waitForAdapterStdioDrain();
+          await this.waitForChildEventFlush();
           this.terminalDapEventForwarded = true;
           this.sendDapEvent('exited', body);
         });
@@ -746,6 +747,7 @@ export class DapProxyWorker {
         // until the streams have drained so the output wins the race.
         return this.enqueueTerminalSignal('terminated', async () => {
           await this.waitForAdapterStdioDrain();
+          await this.waitForChildEventFlush();
           // Must complete before terminated is forwarded: whichever of
           // exited/terminated reaches the SessionManager first strips the
           // other's handler, and shutdown() below tears down the client
@@ -768,6 +770,7 @@ export class DapProxyWorker {
         // hold this path behind the same drain barrier (issue #222).
         return this.enqueueTerminalSignal('dap_connection_closed', async () => {
           await this.waitForAdapterStdioDrain();
+          await this.waitForChildEventFlush();
           this.sendStatus('dap_connection_closed', { expected: this.isTerminationExpected() });
           this.shutdown();
         });
@@ -1593,6 +1596,46 @@ export class DapProxyWorker {
     }
   }
 
+  /**
+   * Drain the DAP client's child-session event chain before forwarding a
+   * terminal signal (issue #366): js-debug delivers debuggee output as CHILD
+   * session events, which are microtask-deferred through the CDP-bridge
+   * serialization chain. Forwarding terminated/exited ahead of that chain
+   * lets the SessionManager tear down its listeners while output is still
+   * queued — silently losing it (reliably so under Docker's slower
+   * scheduling). Bounded by the same 2s backstop as the stdio drain so a
+   * wedged chain cannot hang shutdown.
+   */
+  private async waitForChildEventFlush(): Promise<void> {
+    if (typeof this.dapClient?.flushChildEvents !== 'function') {
+      return;
+    }
+    const boundedFlush = async (): Promise<void> => {
+      const flush = this.dapClient?.flushChildEvents?.();
+      if (!flush) {
+        return;
+      }
+      let timer: NodeJS.Timeout | undefined;
+      const backstop = new Promise<void>(resolve => {
+        timer = setTimeout(resolve, 2000);
+      });
+      try {
+        await Promise.race([flush, backstop]);
+      } finally {
+        if (timer) {
+          clearTimeout(timer);
+        }
+      }
+    };
+    // Two rounds with a short settle: the parent session's terminated can
+    // arrive while child output is still UNREAD in the child socket (not on
+    // the chain yet). The settle lets those bytes be read and enqueued; the
+    // second flush drains them. Only paid by child-session adapters.
+    await boundedFlush();
+    await new Promise(resolve => setTimeout(resolve, 150));
+    await boundedFlush();
+  }
+
   /**
    * Chain a terminal signal onto the FIFO forwarding queue (issue #258).
    * Every producer awaits the drain barrier, so without serialization the
 
@@ -127,6 +127,15 @@ export class MinimalDapClient extends EventEmitter {
     this.childSessionManager?.setExceptionBreakMode(mode);
   }
 
+  /**
+   * Resolves once all child events enqueued so far (output included) have
+   * been forwarded to this client's listeners (issue #366). No-op for
+   * adapters without child sessions.
+   */
+  flushChildEvents(): Promise<void> {
+    return this.childSessionManager?.flushEvents() ?? Promise.resolve();
+  }
+
   /**
    * Handle raw data using the same algorithm as vscode's ProtocolServer
    * (extracted to DapFrameDecoder). This ensures compatibility and proper