@@ -141,10 +141,10 @@ Sets a breakpoint in a source file.
 - `sessionId` (string, required): The ID of the debug session.
 - `file` (string, required): Path to the source file (absolute or relative to project root).
 - `line` (number, required): Line number where to set breakpoint (1-indexed).
-- `statement` (string, optional): **Content addressing** — instead of `line`, pass the text of the target line, like an Edit-tool match — a distinctive substring is enough (leading/trailing whitespace and trailing `//`/`#` comments are ignored; an exact whole-line match always wins over substring matches). Cannot land on the wrong line; if the text appears on multiple lines the error lists every match; anchors re-resolve across `restart_debugging` after file edits. Provide `statement` OR `line`, not both. See [Statement anchors](#statement-anchors).
+- `statement` (string, optional): **Content addressing** — instead of `line`, pass the text of the target line, like an Edit-tool match — a distinctive substring is enough (leading/trailing whitespace and trailing `//`/`#` comments are ignored; an exact whole-line match always wins over substring matches). Can only land on a line containing your stated text — an inexact or multi-candidate match still sets the breakpoint but adds a `warning` to the response; if the text appears on multiple lines the error lists every match; anchors re-resolve across `restart_debugging` after file edits. Provide `statement` OR `line`, not both. See [Statement anchors](#statement-anchors).
 - `function` (string, optional): **Symbol addressing** — break on entry to a function/method by name (DAP function breakpoint). Session-global: no `file` or `line` at all, and names survive edits better than both. Composes with `condition` only. Supported by Python, Go, Rust, C/C++, .NET, Java, and JavaScript (JavaScript names are dotted runtime paths delivered over the CDP bridge — see [Function breakpoints](#function-breakpoints)); Ruby is accepted with a warning and validated at launch.
 - `nearLine` (number, optional): With `statement` only — when the statement text appears on multiple lines, bind to the match closest to this line (ties go to the lower line).
-- `expectedContent` (string, optional): With `line` only — assert the text of the target line before setting; a distinctive substring is enough (leading/trailing whitespace and trailing `//`/`#` comments are ignored). On a mismatch the breakpoint is **not** set and the error shows the actual content of that line and its neighbors — a fast, self-explanatory failure instead of a breakpoint that silently lands on the wrong line. See [Content assertions and loud snapping](#content-assertions-and-loud-snapping).
+- `expectedContent` (string, optional): With `line` only — assert the text of the target line before setting; a distinctive substring is enough (leading/trailing whitespace and trailing `//`/`#` comments are ignored). On a mismatch the breakpoint is **not** set and the error shows the actual content of that line and its neighbors — a fast, self-explanatory failure instead of a breakpoint that silently lands on the wrong line. A relaxed match (substring, or one that only holds after ignoring text past a `//`/`#` marker) still sets the breakpoint but adds a `warning` quoting the actual line. See [Content assertions and loud snapping](#content-assertions-and-loud-snapping).
 - `condition` (string, optional): Conditional expression — only break (or log) when it evaluates truthy.
 - `logMessage` (string, optional): Create a **logpoint** instead of a pausing breakpoint — see [Logpoints](#logpoints) below.
 - `suspendPolicy` (string, optional): Suspend policy when the breakpoint is hit — `"all"` suspends all threads (default), `"thread"` suspends only the event thread. Only supported by the Java/JDI adapter.
@@ -207,12 +207,12 @@ Relatedly, when a debug adapter *accepts* a breakpoint but binds it to a differe
 { "sessionId": "...", "file": "/abs/app.py", "statement": "total = sum(prices)" }
 ```
 
-- **Matching**: whole-line equality after trimming leading/trailing whitespace. Multi-line input is rejected — anchor on the first line of a multi-line construct.
-- **Ambiguity is an error, and the error is the disambiguation UI**: every matching `line: content` pair is listed (capped at 20); add `nearLine` to bind to the closest match.
+- **Matching**: whole-line equality after trimming leading/trailing whitespace; when no exact match exists anywhere, a substring match against comment-stripped lines is accepted (exact matches always win — the two populations never mix). Multi-line input is rejected — anchor on the first line of a multi-line construct.
+- **Ambiguity is an error, and the error is the disambiguation UI**: every matching `line: content` pair is listed (capped at 20); add `nearLine` to bind to the closest match. A `nearLine` pick among multiple matches adds a `warning` naming every candidate line — proximity is a heuristic, not a guarantee.
 - **Blank/comment anchors are rejected** (`#`, `//`, `/*` prefixes) — debuggers cannot break there reliably.
-- **The anchor is stored on the breakpoint record** (visible in `list_breakpoints`) and **re-resolves on `restart_debugging`**: after you edit the file — the whole point of a debug session — the relaunch re-finds each anchored statement in the current file (the breakpoint's previous line breaks ties between duplicates). Moves are reported in the restart response's `data.anchorResolution.moved`; anchors that no longer match keep their previous line and warn (`data.anchorResolution.stale`) rather than failing the restart or dropping state.
+- **The anchor is stored on the breakpoint record** (visible in `list_breakpoints`) and **re-resolves on `restart_debugging`**: after you edit the file — the whole point of a debug session — the relaunch re-finds each anchored statement in the current file (the breakpoint's previous line breaks ties between duplicates). Moves are reported in the restart response's `data.anchorResolution.moved` — a move picked among multiple matching lines carries a `candidates` list and a restart `warning`; anchors that no longer match keep their previous line and warn (`data.anchorResolution.stale`) rather than failing the restart or dropping state.
 - Same readable-file requirement as `expectedContent` (no Java FQCNs, no attach sessions); composes with `condition`, `logMessage`, and `suspendPolicy` unchanged.
-- A matching `expectedContent` alongside `statement` is accepted as redundant; a *different* one is an error (contradictory intent).
+- A matching `expectedContent` alongside `statement` is accepted as redundant (matching under the same relaxed rules: trailing comments ignored, either value may be a substring of the other); a genuinely *different* one is an error (contradictory intent).
 
 #### Function breakpoints
 
 
@@ -48,7 +48,7 @@ Rules that prevent 90% of failed sessions:
 
 1. State a hypothesis about where reality diverges from expectation *before* setting breakpoints.
 2. Set at most two breakpoints: last-known-good and first-known-bad. Run, inspect, halve the interval. Bisection beats stepping line-by-line from the top. Move the window mid-session with `remove_breakpoint` / `clear_breakpoints`; `list_breakpoints` shows what is currently set (with verified state and adapter ids).
-   - Prefer `statement: "<line text>"` over line numbers: it matches like an Edit-tool `old_string` (whole line or a distinctive substring — whitespace-trimmed, trailing comments ignored, exact matches win), cannot land on the wrong line, lists every occurrence on ambiguity (add `nearLine` to pick one), and re-resolves across `restart_debugging` after you edit the file. When you do address by line, pass `expectedContent: "<line text or distinctive substring>"` (trailing comments ignored) so a stale or off-by-one line number fails immediately with the actual nearby lines. A response saying `requested line N, bound to line M` means the adapter moved the breakpoint — trust the bound line.
+   - Prefer `statement: "<line text>"` over line numbers: it matches like an Edit-tool `old_string` (whole line or a distinctive substring — whitespace-trimmed, trailing comments ignored, exact matches win), only lands on a line containing your text (inexact or multi-candidate matches are flagged in the response `warning`), lists every occurrence on ambiguity (add `nearLine` to pick one), and re-resolves across `restart_debugging` after you edit the file. When you do address by line, pass `expectedContent: "<line text or distinctive substring>"` (trailing comments ignored) so a stale or off-by-one line number fails immediately with the actual nearby lines. A response saying `requested line N, bound to line M` means the adapter moved the breakpoint — trust the bound line.
    - `function: "name"` breaks on entry to a symbol with no file or line at all — names survive edits best. Supported by Python/Go/Rust/.NET/Java/JavaScript (Java accepts bare `method`, `Class.method`, or fully-qualified names and binds every concrete overload; JavaScript names are dotted runtime paths like `obj.method` bound to the current function value — main-module function declarations bind at launch, functions in lazily-loaded modules bind at the next pause).
 3. When pausing is too disruptive (hot loops, live or attached processes), use a **logpoint**: `set_breakpoint` with `logMessage: "x={x}"` streams interpolated values into `get_output` without stopping the program (Python/JS/Go/Rust; Java and .NET reject it with a clear error).
 4. At each pause, record what you *learned* (variable values, actual control flow), not just where you are.
 
@@ -176,9 +176,10 @@ export interface IDapClient {
   /**
    * 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.
+   * implements it. Absent method or an undefined return both mean the client
+   * has no child sessions — nothing to flush (issue #378).
    */
-  flushChildEvents?(): Promise<void>;
+  flushChildEvents?(): Promise<void> | undefined;
 }
 
 /**
 
@@ -1607,14 +1607,16 @@ export class DapProxyWorker {
    * wedged chain cannot hang shutdown.
    */
   private async waitForChildEventFlush(): Promise<void> {
-    if (typeof this.dapClient?.flushChildEvents !== 'function') {
+    // An undefined return means the client has no child sessions (issue
+    // #378): every adapter shares MinimalDapClient, so the method exists
+    // everywhere and only its return value tells child-session adapters
+    // apart. Skipping here — not inside the rounds — is what avoids the
+    // settle for python/ruby/go/etc.
+    const firstFlush = this.dapClient?.flushChildEvents?.();
+    if (!firstFlush) {
       return;
     }
-    const boundedFlush = async (): Promise<void> => {
-      const flush = this.dapClient?.flushChildEvents?.();
-      if (!flush) {
-        return;
-      }
+    const boundedFlush = async (flush: Promise<void>): Promise<void> => {
       let timer: NodeJS.Timeout | undefined;
       const backstop = new Promise<void>(resolve => {
         timer = setTimeout(resolve, 2000);
@@ -1630,10 +1632,13 @@ export class DapProxyWorker {
     // 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();
+    // second flush drains them.
+    await boundedFlush(firstFlush);
     await new Promise(resolve => setTimeout(resolve, 150));
-    await boundedFlush();
+    const secondFlush = this.dapClient?.flushChildEvents?.();
+    if (secondFlush) {
+      await boundedFlush(secondFlush);
+    }
   }
 
   /**
 
@@ -129,11 +129,13 @@ export class MinimalDapClient extends EventEmitter {
 
   /**
    * 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.
+   * been forwarded to this client's listeners (issue #366). Returns
+   * undefined for adapters without child sessions so callers can skip the
+   * flush-and-settle entirely (issue #378) — every adapter shares this
+   * client class, so the method's mere presence says nothing.
    */
-  flushChildEvents(): Promise<void> {
-    return this.childSessionManager?.flushEvents() ?? Promise.resolve();
+  flushChildEvents(): Promise<void> | undefined {
+    return this.childSessionManager?.flushEvents();
   }
 
   /**
 
@@ -62,7 +62,7 @@ import {
 } from './utils/bp-addressing.js';
 import { isRedactionEnabled } from './utils/redaction-mode.js';
 import { getVariableAccessMode, requiresExplicitNames } from './utils/variable-access.js';
-import { assertLineContent, resolveStatement } from './utils/breakpoint-resolver.js';
+import { assertLineContent, resolveStatement, stripTrailingComment } from './utils/breakpoint-resolver.js';
 
 const DEFAULT_LANGUAGES = Object.freeze([DebugLanguage.PYTHON, DebugLanguage.MOCK] as const);
 
@@ -693,18 +693,29 @@ export class DebugMcpServer {
         'Provide line or statement, not both. Use nearLine (with statement) to disambiguate repeated statements.'
       );
     }
-    if (
-      req.statement !== undefined &&
-      req.expectedContent !== undefined &&
-      req.statement.trim() !== req.expectedContent.trim()
-    ) {
+    if (req.statement !== undefined && req.expectedContent !== undefined) {
       // A matching expectedContent alongside a statement anchor is redundant
       // but harmless — agents combine them constantly (issue #280), so only
-      // genuinely contradictory intent is an error.
-      throw new McpError(
-        McpErrorCode.InvalidParams,
-        'statement and expectedContent disagree; a statement anchor is already content-addressed. Provide one or the other (a matching expectedContent is accepted as redundant).'
-      );
+      // genuinely contradictory intent is an error. "Matching" mirrors the
+      // relaxed assertLineContent predicate (issue #379): either value may be
+      // the more complete form of the other, and stale trailing comments on
+      // either side are ignored.
+      const stmt = req.statement.trim();
+      const exp = req.expectedContent.trim();
+      const strippedStmt = stripTrailingComment(req.statement).trim();
+      const strippedExp = stripTrailingComment(req.expectedContent).trim();
+      const compatible =
+        stmt.includes(exp) ||
+        exp.includes(stmt) ||
+        (strippedStmt !== '' &&
+          strippedExp !== '' &&
+          (strippedStmt.includes(strippedExp) || strippedExp.includes(strippedStmt)));
+      if (!compatible) {
+        throw new McpError(
+          McpErrorCode.InvalidParams,
+          'statement and expectedContent disagree; a statement anchor is already content-addressed. Provide one or the other (a matching expectedContent is accepted as redundant).'
+        );
+      }
     }
     if (req.nearLine !== undefined && req.statement === undefined) {
       throw new McpError(
@@ -738,13 +749,23 @@ export class DebugMcpServer {
 
     let line: number;
     let anchor: { statement: string; nearLine?: number } | undefined;
+    // Relaxed content matches succeed but must say so (issue #379): a
+    // substring or comment-stripped pass is indistinguishable from an exact
+    // one in the stored breakpoint, so the warning is the agent's only
+    // signal that its stated content only weakly pinned the line.
+    let addressingWarning: string | undefined;
     if (req.statement !== undefined) {
       const lines = await readLinesForContentAddressing('statement addressing');
       const resolution = resolveStatement(lines, req.statement, resolved.path, req.nearLine);
       if (!resolution.ok) {
         throw new McpError(McpErrorCode.InvalidParams, resolution.message);
       }
       line = resolution.line;
+      if (resolution.candidates !== undefined) {
+        addressingWarning =
+          `statement matches ${resolution.candidates.length} lines (${resolution.candidates.join(', ')}); ` +
+          `nearLine ${req.nearLine} selected line ${line} — verify against the echoed content.`;
+      }
       anchor = {
         statement: req.statement.trim(),
         ...(req.nearLine !== undefined ? { nearLine: req.nearLine } : {})
@@ -759,10 +780,19 @@ export class DebugMcpServer {
         if (!check.ok) {
           throw new McpError(McpErrorCode.InvalidParams, check.message);
         }
+        if (check.matchQuality === 'substring') {
+          addressingWarning =
+            `expectedContent matched line ${line} as a substring of "${check.actual}", ` +
+            `not the whole line — confirm this is the intended line.`;
+        } else if (check.matchQuality === 'comment-stripped') {
+          addressingWarning =
+            `expectedContent matched line ${line} only after ignoring text past a '//' or '#' comment marker, ` +
+            `even inside strings (actual: "${check.actual}") — confirm this is the intended line.`;
+        }
       }
     }
 
-    return this.sessionManager.setBreakpoint(req.sessionId, {
+    const result = await this.sessionManager.setBreakpoint(req.sessionId, {
       file: resolved.path,
       line,
       condition: req.condition,
@@ -773,6 +803,13 @@ export class DebugMcpServer {
       ...(supportsLoudSnapping(mode) ? { requestedLine: line } : {}),
       ...(anchor !== undefined ? { anchor } : {})
     });
+    if (addressingWarning === undefined) {
+      return result;
+    }
+    return {
+      ...result,
+      warning: result.warning ? `${result.warning}; ${addressingWarning}` : addressingWarning
+    };
   }
 
   // The breakpoint management tools below deliberately skip validateSession's
@@ -1016,7 +1053,7 @@ export class DebugMcpServer {
       if (supportsStatementAnchors(bpMode)) {
         setBreakpointExtraProps.statement = {
           type: 'string',
-          description: 'Address by content instead of line number: the text of the target line, like an Edit-tool match — a distinctive substring is enough (leading/trailing whitespace and trailing //- or #-comments are ignored; an exact whole-line match always wins over substring matches). Preferred over line — it cannot land on the wrong line and survives file edits across restart_debugging. If the text appears on multiple lines, the error lists every match; add nearLine to pick one. Provide statement OR line, not both'
+          description: 'Address by content instead of line number: the text of the target line, like an Edit-tool match — a distinctive substring is enough (leading/trailing whitespace and trailing //- or #-comments are ignored; an exact whole-line match always wins over substring matches). Preferred over line — it can only land on a line containing your text (an inexact or multi-candidate match adds a warning to the response) and survives file edits across restart_debugging. If the text appears on multiple lines, the error lists every match; add nearLine to pick one. Provide statement OR line, not both'
         };
         setBreakpointExtraProps.nearLine = {
           type: 'number',