diff --git a/changelog.d/655.fixed.md b/changelog.d/655.fixed.md
new file mode 100644
index 00000000..19b532cd
--- /dev/null
+++ b/changelog.d/655.fixed.md
@@ -0,0 +1 @@
+**js `get_stack_trace` shows the user's frames, not the framework's** — on a js attach session paused inside an express/MCP server, `includeInternals: false` still returned ~60 frames: forty `node_modules/.pnpm/…` router/body-parser frames, ten phantom relative `../src/*.ts` paths (js-debug had applied every dependency's `.js.map`, whose sources are not shipped), and `<unknown_source>` `await`/`Promise.then` separators. `JsDebugAdapterPolicy.isInternalFrame` matched only `<node_internals>`. It now also hides any `node_modules` path segment (pnpm and Windows layouts included) and sourceless line-0 async separators, and drops its local first-frame fallback so the central issue-#346 guarantee (`allFramesInternal` + note) finally engages for JS. On attach, `resolveSourceMapLocations` defaults to launch's `["**", "!**/node_modules/**"]` (js-debug's own attach default collapses to "resolve everywhere") so dependency frames report their real `.js` path, and `cwd` defaults to the server's working directory because js-debug resolves no relative map source without a base path — the debuggee's own `dist/**` maps now resolve to the absolute `src/**/*.ts` beside them instead of an unopenable `../src/…` label. Frames the adapter still cannot place on disk carry `unresolvedSource: true` and the response `note` says their `file` is a label, not a path. `skipFiles` is deliberately untouched on attach — blackboxing `node_modules` would re-open the #513 pause step-chase (#655)
diff --git a/docs/agent-debugging-guide.md b/docs/agent-debugging-guide.md
index 99b40f33..49920813 100644
--- a/docs/agent-debugging-guide.md
+++ b/docs/agent-debugging-guide.md
@@ -125,7 +125,7 @@ evaluate_expression(sessionId=session_id, expression="a + b")  # Returns: "3"
 ## Common Issues and Solutions
 
 ### Issue: JavaScript shows Node.js internals in stack trace
-**Solution:** Use `continue_execution` to move past internal frames. Stack trace filtering hides internal frames by default for supported languages.
+**Solution:** Use `continue_execution` to move past internal frames. Stack trace filtering hides Node internals, `node_modules` dependency frames, and async separators by default; `includeInternals: true` shows them. A frame marked `unresolvedSource: true` is a source-map label, not a file you can open.
 
 ### Issue: Python shows "special variables" instead of actual variables
 **Solution:** This is normal hierarchical organization. Use the `variablesReference` to expand:
@@ -446,7 +446,7 @@ capability, not a view-only credential.
 ## Summary
 
 The MCP Debugger is fully functional for Python, Ruby, JavaScript, Rust, Go, Java, .NET/C#, and C/C++. The key insights are:
-- **JavaScript**: Stack trace filtering hides internal frames; may need `continue_execution` if initially stopped at internals
+- **JavaScript**: Stack trace filtering hides internal, `node_modules`, and async-separator frames; may need `continue_execution` if initially stopped at internals
 - **Python**: Use variablesReference to expand variable containers
 - **Ruby**: Supports launch and attach flows through `rdbg`; use Bundler mode for Rails and RSpec-style entrypoints
 - **Rust**: CodeLLDB adapter is vendored; the GNU toolchain is required for reliable debugging -- MSVC-built binaries may produce errors with CodeLLDB. Set `RUST_MSVC_BEHAVIOR` env var to control MSVC handling
diff --git a/docs/architecture/adapter-policy-pattern.md b/docs/architecture/adapter-policy-pattern.md
index 8f80a420..ca8c9a10 100644
--- a/docs/architecture/adapter-policy-pattern.md
+++ b/docs/architecture/adapter-policy-pattern.md
@@ -237,7 +237,7 @@ whenever it is among the contributors.
 - `requiresCommandQueueing()` returns `true` -- commands are queued until initialize response, then reordered (configs -> configurationDone -> launch -> others)
 - Provides a full `performHandshake()` implementation for the js-debug multi-session setup
 - `isChildReadyEvent()` waits for `'thread'` or `'stopped'` (not `'initialized'`)
-- `filterStackFrames()` removes `<node_internals>` frames
+- `filterStackFrames()` removes `<node_internals>`/`node:` frames, any `node_modules` path segment, and sourceless line-0 async separators (issue #655); no local fallback — `FrameAnchorResolver` owns the all-internal case
 - `extractLocalVariables()` treats the local-like group as a COLLECTING group: every non-empty block scope (`Block`, `Catch Block`, `With Block`, legacy `Block:<label>`) in adapter order — which V8 gives innermost-first — followed by the frame's `Local` scope (issue #558). A `Local` scope that exists but contributed nothing (only `this`, or emptied by a pushed-down `names` filter) still has its ref reported, so the session layer keeps naming it `Local` with no note. On an ESM top-level frame — blocks but no `Local` at all — the first `Script`/`Module` scope joins the merge as the frame's base, because that is what such a frame reported before block scopes were recognised; with a `Local` present, `Module` stays a fall-through-only scope. When nothing local-like yields anything, the later groups fall through first-match: `Closure`, then `Script`/`Module`, and `Global` only for frames with no local or block scope at all
 - All three places that knew JS scope names — the extractor's predicates and `getLocalScopeName()` — now read one `JS_SCOPE_KINDS` table, because a disagreement between them is exactly how a false `note` shipped once. It is exported from the `@debugmcp/shared` package root (`adapter-policy-js.ts`). The LLDB policies use the same one-table idea for their own scope names, but `LLDB_LOCAL_SCOPE_NAMES` lives in `lldb-policy-shared.ts` and is imported only within the shared package, not re-exported from the root
 
diff --git a/docs/javascript/README.md b/docs/javascript/README.md
index 6124d2fc..7d0789d4 100644
--- a/docs/javascript/README.md
+++ b/docs/javascript/README.md
@@ -228,6 +228,22 @@ If neither `tsx` nor `ts-node` is installed, the factory emits a warning (not an
   `state: "running", pending: true` (the `message` names the pending pause) and
   freezes on its next request — attach to a live server with `stopOnEntry: false`
 - Some advanced DAP features may not be exposed through MCP tools
+- **Source-mapped frames you cannot open.** A package that ships `.js.map` files
+  whose `sources` point at `.ts` files it did not ship makes js-debug report those
+  frames with a relative label (`../src/shared/protocol.ts`) and a non-zero
+  `sourceReference`; mcp-debugger marks them `unresolvedSource: true` and says so
+  in the `note` (issue #655). On attach the common causes are already handled:
+  `resolveSourceMapLocations` defaults to `["**", "!**/node_modules/**"]` so
+  dependency maps are not applied (those frames show their real `.js` path), and
+  `cwd` defaults to the server's working directory because js-debug resolves no
+  relative map source without a base path — with it, the debuggee's own
+  `dist/**` maps resolve to the absolute `src/**/*.ts` next to them. Knobs, all via
+  `adapterConfig`: `sourceMaps: false` (generated `.js` paths everywhere),
+  `resolveSourceMapLocations` (globs, or `null` for everywhere), `cwd`,
+  `sourceMapPathOverrides`. `get_stack_trace` hides `node_modules` and async
+  separator frames by default; a debuggee that is itself an installed package
+  under `node_modules` shows its top frame plus an "all frames are internal"
+  note — pass `includeInternals: true`
 - Debuggee exit codes are captured via an injected preload (js-debug itself
   never emits a DAP `exited` event), so `exitCode` is unavailable in two
   cases: attach mode (the target's environment is not under mcp-debugger's
diff --git a/docs/stack-trace-filtering.md b/docs/stack-trace-filtering.md
index 7f159be0..c0427390 100644
--- a/docs/stack-trace-filtering.md
+++ b/docs/stack-trace-filtering.md
@@ -4,7 +4,7 @@
 `get_stack_trace` applies language-specific stack trace filtering, hiding internal/framework frames by default so the caller sees user code first.
 
 ## Features
-- **JavaScript/Node.js**: Filters out `<node_internals>` frames by default
+- **JavaScript/Node.js**: Filters out `<node_internals>`/`node:` frames, any frame under a `node_modules` path segment (pnpm's nested layout and Windows separators included), and js-debug's sourceless async separators (`await`, `Promise.then`, `bound-anonymous-fn` at line 0) by default (issue #655)
 - **Go**: Filters out `/runtime/` and `/testing/` frames by default
 - **Java**: Filters out JDK internal frames by default
 - **.NET/C#**: Filters out `System.*` and `Microsoft.*` runtime frames and sourceless frames by default
@@ -28,10 +28,12 @@ When calling `get_stack_trace` without parameters or with `includeInternals: fal
 }
 ```
 
-For JavaScript, this will return only user code frames, filtering out Node.js internals like:
-- `<node_internals>/internal/modules/...`
-- `<node_internals>/internal/process/...`
-- etc.
+For JavaScript, this will return only user code frames, filtering out:
+- Node.js internals: `<node_internals>/internal/modules/...`, `<node_internals>/internal/process/...`
+- Dependencies: `/app/node_modules/express/lib/router/index.js`, `/app/node_modules/.pnpm/router@2.2.0/node_modules/router/lib/layer.js`
+- Async separators: `await` / `Promise.then` frames with no source and `line: 0`
+
+The match is on a `node_modules` path *segment*, so `/app/src/node_modules_helper.js` is user code, and workspace packages (which Node realpaths to their `packages/...` location) stay visible. A debuggee that is itself an installed package (`/usr/lib/node_modules/<pkg>/...`) becomes all-internal — the top frame is kept and the `note` says so (see Edge Cases).
 
 ### Including Internal Frames
 To see all frames including internals:
@@ -90,8 +92,8 @@ The filtering is implemented using the existing `AdapterPolicy` system:
 
 2. **JsDebugAdapterPolicy** (`packages/shared/src/interfaces/adapter-policy-js.ts`)
    - Implements filtering for JavaScript
-   - Identifies internal frames by checking for `<node_internals>` in the file path
-   - Keeps at least one frame if all are filtered
+   - Identifies internal frames by path: `<node_internals>`/`node:`, any `node_modules` segment, and sourceless line-0 async separators (issue #655); `frame.name` never participates
+   - No local fallback — the central `FrameAnchorResolver` guarantee below owns the all-internal case
 
 3. **GoAdapterPolicy** (`packages/shared/src/interfaces/adapter-policy-go.ts`)
    - Implements filtering for Go
@@ -117,8 +119,9 @@ The filtering is implemented using the existing `AdapterPolicy` system:
    - Turns that metadata into the `hiddenFrames` field and the `note` sentence
 
 ### Edge Cases Handled
-- **All frames internal**: The filtered stack is never empty when the adapter reported frames. `FrameAnchorResolver` keeps the top (unfiltered) frame and sets `allFramesInternal`, so `get_scopes` and `evaluate_expression` always have a valid `frameId`; the `note` says so and points at `includeInternals: true` (issue #346). This guarantee is central and applies to every language, Go and .NET included. Two policies additionally soften the result themselves — JS retains the first frame, Java returns the full unfiltered array (so a thread parked deep in JDK code still shows its stack)
+- **All frames internal**: The filtered stack is never empty when the adapter reported frames. `FrameAnchorResolver` keeps the top (unfiltered) frame and sets `allFramesInternal`, so `get_scopes` and `evaluate_expression` always have a valid `frameId`; the `note` says so and points at `includeInternals: true` (issue #346). This guarantee is central and applies to every language, Go and .NET included. One policy additionally softens the result itself — Java returns the full unfiltered array (so a thread parked deep in JDK code still shows its stack)
 - **No frames**: Returns empty array as before
+- **Unresolvable source-mapped frames** (issue #655): when the adapter reports a frame's source as not-a-file-on-this-host (DAP `sourceReference != 0` with a real-looking path — js-debug does this for a source map's `../src/x.ts` that the package never shipped), the frame carries `unresolvedSource: true` and the `note` says its `file` is a label, not an openable path. These frames are the debuggee's own code and are never hidden. On js attach this is rare now: `resolveSourceMapLocations` excludes `node_modules` by default (so dependency maps are not applied and those frames report their real `.js` path) and `cwd` is defaulted so the debuggee's own relative map sources resolve
 - **Python**: No filtering applied (Python's AdapterPolicy does not implement `filterStackFrames`)
 - **Other languages**: Any language whose AdapterPolicy implements `filterStackFrames` has filtering applied
 
diff --git a/docs/tool-reference.md b/docs/tool-reference.md
index 03b0fab0..6c870070 100644
--- a/docs/tool-reference.md
+++ b/docs/tool-reference.md
@@ -653,7 +653,8 @@ Gets the current call stack.
 - Stack frames are ordered from innermost (current) to outermost
 - `threadId` identifies the thread represented by `stackFrames`, or the explicitly queried thread when the stack is empty. `lastStop.threadId`, when present, remains the thread reported by the original stop event.
 - Frame IDs are used with `get_scopes`
-- Internal/runtime frames (e.g. Node.js internals, Go `/runtime/`, `System.*`) are filtered out by default; pass `includeInternals: true` to see them. When any frames were hidden, the response additionally carries `hiddenFrames` (count) and a `note` explaining how to reveal them.
+- Internal/runtime frames (e.g. Node.js internals and `node_modules` dependencies, Go `/runtime/`, `System.*`) are filtered out by default; pass `includeInternals: true` to see them. When any frames were hidden, the response additionally carries `hiddenFrames` (count) and a `note` explaining how to reveal them.
+- A frame whose source the adapter could not find on this host (js-debug: a source-mapped `.ts` the package did not ship) carries `unresolvedSource: true`, and the `note` says its `file` is a label rather than an openable path — do not pass it to `get_source_context`.
 - The filtered stack is never empty when the adapter reported frames: if *every* frame is internal (e.g. a goroutine paused inside the Go runtime), the top internal frame is kept so `get_scopes`/`evaluate_expression` still have a valid `frameId`, and the `note` says so.
 - When an explicit thread reports no frames, the response remains anchored to that thread and its `note` suggests a frame-bearing alternative when one is available.
 - When the implicit stopped thread is frameless, stack, locals, and default evaluation share one resolver. It scans siblings, prefers a thread whose frames the language policy recognizes as user code over runtime-only stacks, adopts it once, and discloses the switch in `note`/`anchorNote`.
@@ -1155,7 +1156,7 @@ When the requested pause has not landed by the time the tool answers (an idle No
 - `state` is `"paused"` only once a stopped event has actually been observed; otherwise the attach reports `"running"`. When a requested post-attach pause is accepted but its stopped event has not arrived within the bounded wait, the response is successful with `state: "running"` and `pending: true` (at the top level and in `data`) and the `message` names the pending pause; the late stopped event is the only transition to `paused`, and every paused session has a `lastStop`.
 - When `processId` was used, the message reads `Attached to process PID <pid>` instead.
 - The response `warning` reports two distinct `adapterConfig` key outcomes (issues #450/#466): keys the adapter's attach transform genuinely drops (e.g. Python's ptvsd-era `localRoot`/`remoteRoot` — use `pathMappings`) are named as **ignored**, while keys mcp-debugger doesn't recognize are **forwarded to the adapter as-is** and named with an edit-distance suggestion for near-misses (`pathMapping (did you mean pathMappings?)`) — "ignored" means dropped, "forwarded as-is" means the adapter still sees them. The same field also carries the launch-style warning for function breakpoints still unverified at attach (issue #308).
-- js-debug attach honors `adapterConfig` too: `localRoot`/`remoteRoot`/`sourceMaps`/`skipFiles`/`continueOnAttach` and other js-debug attach options reach the debugger (issue #466).
+- js-debug attach honors `adapterConfig` too: `localRoot`/`remoteRoot`/`sourceMaps`/`skipFiles`/`continueOnAttach` and other js-debug attach options reach the debugger (issue #466). Two keys are defaulted when absent (issue #655): `resolveSourceMapLocations: ["**", "!**/node_modules/**"]` (js-debug's own attach default collapses to "resolve everywhere", which applied every dependency's `.js.map` and produced phantom `../src/*.ts` frames) and `cwd` (the server's working directory, or the workspace root in container mode — js-debug needs a base path before it resolves any source map's relative `sources`, even ones next to the generated file). Pass your own value, including `resolveSourceMapLocations: null`, to override. `skipFiles` is deliberately left at js-debug's default: blackboxing `node_modules` would turn a `pause_execution` that lands in framework code on an idle server into the endless step-chase of issue #513 — `get_stack_trace` hides those frames instead.
 - Breakpoints set before the attach are re-sent once the debuggee-owning session is provably live, so their verified state in `list_breakpoints` is authoritative.
 - Languages whose adapter has no attach implementation (`rust`, `go`, `mock`) fail fast with a clear error.
 - A failed attach reports `success: false` with the reason in `message` (`Failed to attach: ...`) and tears the proxy down, so no live proxy is left behind; `state` is then `"error"` (or `"stopped"` if the session was already gone). When the failure happened during proxy initialization, `data` carries `proxyLogPath`, `proxyLogResource`, and `initProgress` diagnostics. Session-lifecycle failures (unknown or terminated session) return the standard application-level `error` payload instead — see [Error Handling](#error-handling).
diff --git a/docs/usage.md b/docs/usage.md
index 94b5f29f..c7c4e4d8 100644
--- a/docs/usage.md
+++ b/docs/usage.md
@@ -353,7 +353,7 @@ You can also evaluate arbitrary expressions in the current debug context:
 - Narrow the request to escape the cap: pass `names: ["a", "b"]` to `get_variables` or `get_local_variables` to fetch specific variables in full. Requested names that were not found are listed in the response's `notFound`
 
 ### Stack Trace Filtering
-- `get_stack_trace` filters internal/runtime frames by default. When any are hidden the response carries `hiddenFrames` (the count) and a `note` saying so; pass `includeInternals: true` to get the full stack
+- `get_stack_trace` filters internal/runtime frames by default (for JavaScript: Node internals, `node_modules` dependencies, and async separators). When any are hidden the response carries `hiddenFrames` (the count) and a `note` saying so; pass `includeInternals: true` to get the full stack. A frame with `unresolvedSource: true` has a `file` that is a label, not an openable path
 
 ### Breakpoint Behavior
 - Breakpoints initially show `"verified": false` because verification happens asynchronously by the debug adapter once the module is loaded (e.g., debugpy verifies after the script starts)
diff --git a/packages/adapter-javascript/src/javascript-debug-adapter.ts b/packages/adapter-javascript/src/javascript-debug-adapter.ts
index 0a506c18..7a17de39 100644
--- a/packages/adapter-javascript/src/javascript-debug-adapter.ts
+++ b/packages/adapter-javascript/src/javascript-debug-adapter.ts
@@ -37,6 +37,19 @@ import { determineOutFiles, isESMProject, hasTsConfigPaths } from './utils/confi
 import { JsDebugLaunchBarrier } from './utils/js-debug-launch-barrier.js';
 import { jsDebugCandidatePaths } from './utils/js-debug-resolver.js';
 
+/**
+ * Base path js-debug uses to resolve source-map `sources` on attach (issue
+ * #655): the same fallback transformLaunchConfig applies when no program
+ * directory is known — the workspace root in container mode, else the
+ * server's working directory (VS Code's `${workspaceFolder}` equivalent).
+ */
+function defaultAttachCwd(): string {
+  if (process.env.MCP_CONTAINER === 'true') {
+    return process.env.MCP_WORKSPACE_ROOT || '/workspace';
+  }
+  return process.cwd();
+}
+
 export class JavascriptDebugAdapter extends EventEmitter implements IDebugAdapter {
   readonly language = 'javascript' as unknown as DebugLanguage;
   readonly name = 'JavaScript/TypeScript Debug Adapter';
@@ -700,6 +713,29 @@ export class JavascriptDebugAdapter extends EventEmitter implements IDebugAdapte
       // off for attach — pausing an attached process must land truthfully,
       // even in an internal frame; an explicit caller value wins.
       smartStep: typeof rest.smartStep === 'boolean' ? rest.smartStep : false,
+      // Source-map resolution on attach (issue #655). js-debug's pwa-node
+      // attach defaults resolveSourceMapLocations to ['**','!**/node_modules/**'],
+      // but its applyNodeDefaults copies an undefined outFiles over that
+      // default before the spread, and without a workspace folder the value
+      // collapses to null (= resolve maps everywhere). Dependencies that ship
+      // .js.map files without their sources then surface as phantom
+      // '../src/*.ts' frames. Pass launch's exclusion explicitly; an explicit
+      // caller value — including null — wins ('in' check, not Array.isArray).
+      // skipFiles is deliberately NOT defaulted: '**/node_modules/**' would
+      // V8-blackbox dependency scripts and turn a pause landing in framework
+      // glue on an idle server into the #513 step-chase; the policy hides
+      // those frames from get_stack_trace instead.
+      ...('resolveSourceMapLocations' in rest
+        ? {}
+        : { resolveSourceMapLocations: ['**', '!**/node_modules/**'] }),
+      // js-debug resolves a source map's relative `sources` only when it has
+      // a base path, and its attach path leaves cwd undefined — so even the
+      // debuggee's own '../../src/x.ts' entries (which do exist next to
+      // dist/) were reported as unopenable relative labels. The value only
+      // gates the resolution (sources resolve against the map's own
+      // location, verified with a deliberately wrong cwd); default it the way
+      // launch does when no program dir is known. An explicit caller value wins.
+      ...('cwd' in rest ? {} : { cwd: defaultAttachCwd() }),
     } as LanguageSpecificAttachConfig;
   }
 
diff --git a/packages/adapter-javascript/tests/unit/javascript-debug-adapter.transform.test.ts b/packages/adapter-javascript/tests/unit/javascript-debug-adapter.transform.test.ts
index 9ca96bed..9b594e78 100644
--- a/packages/adapter-javascript/tests/unit/javascript-debug-adapter.transform.test.ts
+++ b/packages/adapter-javascript/tests/unit/javascript-debug-adapter.transform.test.ts
@@ -331,6 +331,48 @@ describe('JavascriptDebugAdapter.transformLaunchConfig', () => {
     });
   });
 
+  describe('transformAttachConfig source-map defaults (issue #655)', () => {
+    it('defaults resolveSourceMapLocations to the launch exclusion and cwd to the server cwd', () => {
+      const adapter = new JavascriptDebugAdapter(deps);
+      const cfg = adapter.transformAttachConfig({ request: 'attach', port: 9229 } as any) as Record<string, unknown>;
+      expect(cfg.resolveSourceMapLocations).toEqual(['**', '!**/node_modules/**']);
+      expect(cfg.cwd).toBe(process.cwd());
+      // Deliberately not defaulted: blackboxing node_modules would recreate
+      // the #513 pause step-chase; the policy hides those frames instead.
+      expect(cfg.skipFiles).toBeUndefined();
+      expect(cfg.sourceMaps).toBeUndefined();
+      expect(cfg.outFiles).toBeUndefined();
+    });
+
+    it('keeps a caller resolveSourceMapLocations — including an explicit null — and a caller cwd', () => {
+      const adapter = new JavascriptDebugAdapter(deps);
+      const list = adapter.transformAttachConfig({
+        request: 'attach', port: 9229, resolveSourceMapLocations: ['/app/**'], cwd: '/app'
+      } as any) as Record<string, unknown>;
+      expect(list.resolveSourceMapLocations).toEqual(['/app/**']);
+      expect(list.cwd).toBe('/app');
+
+      const everywhere = adapter.transformAttachConfig({
+        request: 'attach', port: 9229, resolveSourceMapLocations: null
+      } as any) as Record<string, unknown>;
+      expect(everywhere.resolveSourceMapLocations).toBeNull();
+    });
+
+    it('uses the workspace root as cwd in container mode', () => {
+      const prev = { c: process.env.MCP_CONTAINER, w: process.env.MCP_WORKSPACE_ROOT };
+      process.env.MCP_CONTAINER = 'true';
+      process.env.MCP_WORKSPACE_ROOT = '/ws';
+      try {
+        const adapter = new JavascriptDebugAdapter(deps);
+        const cfg = adapter.transformAttachConfig({ request: 'attach', port: 9229 } as any) as Record<string, unknown>;
+        expect(cfg.cwd).toBe('/ws');
+      } finally {
+        if (prev.c === undefined) delete process.env.MCP_CONTAINER; else process.env.MCP_CONTAINER = prev.c;
+        if (prev.w === undefined) delete process.env.MCP_WORKSPACE_ROOT; else process.env.MCP_WORKSPACE_ROOT = prev.w;
+      }
+    });
+  });
+
   describe('transformAttachConfig passthrough (issues #450/#466)', () => {
     it('normalizes the pwa-node attach shape and defaults the host', () => {
       const adapter = new JavascriptDebugAdapter(deps);
diff --git a/packages/shared/src/interfaces/adapter-policy-js.ts b/packages/shared/src/interfaces/adapter-policy-js.ts
index 3e3135a0..0a0cb647 100644
--- a/packages/shared/src/interfaces/adapter-policy-js.ts
+++ b/packages/shared/src/interfaces/adapter-policy-js.ts
@@ -76,6 +76,14 @@ export interface JsAdapterState extends AdapterSpecificState {
   pendingCommands: QueuedDapCommand[];
 }
 
+/** A `node_modules` path *segment*, either separator (issue #655). */
+const NODE_MODULES_SEGMENT = /[\\/]node_modules[\\/]/;
+
+/** No source at all: the resolver's `<unknown_source>` placeholder or an empty path. */
+function hasNoSource(filePath: string): boolean {
+  return filePath === '' || filePath === '<unknown_source>';
+}
+
 export const JsDebugAdapterPolicy: AdapterPolicy = {
   name: 'js-debug',
   supportsLogPoints: true,
@@ -155,32 +163,58 @@ export const JsDebugAdapterPolicy: AdapterPolicy = {
   },
 
   /**
-   * Check if a stack frame is a Node.js internal frame
+   * Classify a frame as runtime/dependency glue rather than the user's code
+   * (issue #655). Three rules, all path-based:
+   *
+   * 1. Node internals — `<node_internals>/…` (js-debug already rewrites
+   *    `node:` URLs to that form; the bare `node:` prefix is kept as a
+   *    belt-and-braces for other DAP servers and `source.name` fallbacks).
+   * 2. Any `node_modules` path segment — pnpm's
+   *    `node_modules/.pnpm/express@4/node_modules/express/…`, Windows
+   *    `C:\app\node_modules\…`, and `file:///…/node_modules/…` URLs. A
+   *    *segment* match, not a substring, so `/app/src/node_modules_helper.js`
+   *    stays visible. Workspace packages are realpathed by Node, so a monorepo
+   *    package linked under `node_modules/@scope/pkg` reports its real
+   *    `packages/pkg/…` path and stays visible; only `--preserve-symlinks`
+   *    hides it — the same rule launch already applies via `skipFiles`. A
+   *    debuggee that *is* an installed package (`/usr/lib/node_modules/<pkg>`)
+   *    becomes all-internal: the central issue-#346 fallback keeps frame 0 and
+   *    the response note says so; `includeInternals: true` shows everything.
+   * 3. js-debug's async separators — `await` / `Promise.then` /
+   *    `bound-anonymous-fn` labels with no source at all and `line: 0`. A
+   *    sourceless frame that still reports a line (an eval'd `VM123` script)
+   *    is not matched.
+   *
+   * `frame.name` deliberately does not participate: `processTicksAndRejections`
+   * carries a `<node_internals>` path (rule 1), the separators are rule 3, and
+   * a name rule would only add false positives (a user function named `then`).
+   * Unresolvable source-mapped frames (a relative `../src/x.ts` js-debug could
+   * not find on disk) are NOT internal — they are the debuggee's own code and
+   * are annotated with `unresolvedSource` by the frame resolver instead.
    */
   isInternalFrame: (frame: StackFrame): boolean => {
-    // Node.js internal frames are identified by <node_internals> in the path
     const filePath = frame.file || '';
-    return filePath.includes('<node_internals>');
+    if (filePath.includes('<node_internals>') || filePath.startsWith('node:')) {
+      return true;
+    }
+    if (NODE_MODULES_SEGMENT.test(filePath)) {
+      return true;
+    }
+    return hasNoSource(filePath) && (frame.line ?? 0) === 0;
   },
-  
+
   /**
-   * Filter stack frames to optionally remove Node.js internals
+   * Filter stack frames to optionally remove Node.js internals and
+   * dependency frames. No local first-frame fallback: the frame resolver in
+   * the session layer restores the top frame for an all-internal stack and
+   * sets `allFramesInternal` (issue #346); a fallback here used to mask that
+   * flag and report "N-1 hidden" with the wrong note.
    */
   filterStackFrames: (frames: StackFrame[], includeInternals: boolean): StackFrame[] => {
-    // If including internals, return all frames
     if (includeInternals) {
       return frames;
     }
-    
-    // Filter out internal frames
-    const filtered = frames.filter(frame => !JsDebugAdapterPolicy.isInternalFrame!(frame));
-    
-    // Edge case: If all frames were filtered out, keep at least the first frame
-    if (filtered.length === 0 && frames.length > 0) {
-      return [frames[0]];
-    }
-    
-    return filtered;
+    return frames.filter(frame => !JsDebugAdapterPolicy.isInternalFrame!(frame));
   },
 
   /**
@@ -593,6 +627,18 @@ export const JsDebugAdapterPolicy: AdapterPolicy = {
             ? (a.autoAttachChildProcesses as boolean)
             : false;
       }
+      // Same self-containment for resolveSourceMapLocations (issue #655):
+      // js-debug's attach defaults collapse it to null without a workspace
+      // folder, applying every dependency's .js.map. The adapter transform
+      // already sets launch's exclusion; keep it for embedders that bypass
+      // the transform. Only an absent key is defaulted — an explicit null
+      // ("resolve everywhere") is a caller decision.
+      if (!('resolveSourceMapLocations' in attachArgs)) {
+        attachArgs.resolveSourceMapLocations =
+          'resolveSourceMapLocations' in a
+            ? a.resolveSourceMapLocations
+            : ['**', '!**/node_modules/**'];
+      }
       try {
         console.info(`[JsDebugAdapterPolicy] [JS] Sending 'attach' to ${attachPort} (address=${attachHost})`);
         await pm.sendDapRequest('attach', attachArgs);
diff --git a/packages/shared/src/models/index.ts b/packages/shared/src/models/index.ts
index a9121666..0de3a58c 100644
--- a/packages/shared/src/models/index.ts
+++ b/packages/shared/src/models/index.ts
@@ -438,6 +438,13 @@ export interface StackFrame {
   line: number;
   /** Column number */
   column?: number;
+  /**
+   * True when the adapter reports this frame's source is not a file on this
+   * host (DAP `sourceReference != 0` with a non-placeholder path) — typically
+   * a source-mapped original the package did not ship. `file` is then a
+   * label, not an openable path (issue #655).
+   */
+  unresolvedSource?: boolean;
 }
 
 /**
diff --git a/packages/shared/tests/unit/adapter-policy-js.spec.ts b/packages/shared/tests/unit/adapter-policy-js.spec.ts
index f79830dc..0beae948 100644
--- a/packages/shared/tests/unit/adapter-policy-js.spec.ts
+++ b/packages/shared/tests/unit/adapter-policy-js.spec.ts
@@ -63,7 +63,7 @@ describe('JsDebugAdapterPolicy', () => {
   });
 
   describe('filterStackFrames', () => {
-    it('filters out internal frames but keeps first when all removed', () => {
+    it('filters out internal frames and returns [] when all are removed (the resolver owns the #346 fallback)', () => {
       const frames = [
         createStackFrame(1, '<node_internals>/lib.js'),
         createStackFrame(2, '/workspace/app.js'),
@@ -72,10 +72,36 @@ describe('JsDebugAdapterPolicy', () => {
       expect(filtered).toHaveLength(1);
       expect(filtered[0].id).toBe(2);
 
+      // Issue #655: no local first-frame fallback — a local copy masked the
+      // central allFramesInternal flag and produced "N-1 hidden".
       const allInternal = [createStackFrame(3, '<node_internals>/timer.js')];
-      const fallback = JsDebugAdapterPolicy.filterStackFrames!(allInternal, false);
-      expect(fallback).toHaveLength(1);
-      expect(fallback[0].id).toBe(3);
+      expect(JsDebugAdapterPolicy.filterStackFrames!(allInternal, false)).toEqual([]);
+      expect(JsDebugAdapterPolicy.filterStackFrames!(allInternal, true)).toHaveLength(1);
+    });
+  });
+
+  describe('isInternalFrame (issue #655)', () => {
+    const frame = (file: string | undefined, line: number, name = 'fn') =>
+      ({ id: 1, name, line, column: 0, file: file as string });
+    const cases: Array<{ desc: string; file: string | undefined; line: number; name?: string; internal: boolean }> = [
+      { desc: 'node internals', file: '<node_internals>/internal/process/task_queues', line: 103, internal: true },
+      { desc: 'bare node: URL', file: 'node:internal/timers', line: 507, internal: true },
+      { desc: 'node_modules dependency', file: '/app/node_modules/express/lib/router/index.js', line: 1, internal: true },
+      { desc: 'pnpm nested node_modules', file: '/app/node_modules/.pnpm/router@2.2.0/node_modules/router/lib/layer.js', line: 152, internal: true },
+      { desc: 'Windows node_modules', file: 'C:\\app\\node_modules\\hono\\dist\\hono.js', line: 9, internal: true },
+      { desc: 'file:// node_modules URL', file: 'file:///app/node_modules/x/index.js', line: 3, internal: true },
+      { desc: 'user file whose name contains node_modules', file: '/app/src/node_modules_helper.js', line: 4, internal: false },
+      { desc: 'monorepo package (realpathed)', file: '/app/packages/api/src/handler.ts', line: 10, internal: false },
+      { desc: 'async separator with <unknown_source>', file: '<unknown_source>', line: 0, name: 'await', internal: true },
+      { desc: 'async separator with empty file', file: '', line: 0, name: 'Promise.then', internal: true },
+      { desc: 'async separator with undefined file', file: undefined, line: 0, name: 'bound-anonymous-fn', internal: true },
+      { desc: 'sourceless frame that reports a line', file: '<unknown_source>', line: 12, internal: false },
+      { desc: 'eval script', file: '<eval>/VM123', line: 1, internal: false },
+      { desc: 'name alone never classifies', file: '/app/src/queue.js', line: 8, name: 'Promise.then', internal: false },
+      { desc: 'unresolved source-mapped path is user code', file: '../src/shared/protocol.ts', line: 40, internal: false },
+    ];
+    it.each(cases)('$desc -> $internal', ({ file, line, name, internal }) => {
+      expect(JsDebugAdapterPolicy.isInternalFrame!(frame(file, line, name))).toBe(internal);
     });
   });
 
diff --git a/src/server/handlers/inspection-tools.ts b/src/server/handlers/inspection-tools.ts
index fa0c9ee1..50533542 100644
--- a/src/server/handlers/inspection-tools.ts
+++ b/src/server/handlers/inspection-tools.ts
@@ -84,6 +84,14 @@ export const getStackTraceTool: ToolHandler = async (ctx, args) => {
         ? `All ${stackTrace.totalFrameCount} frames are internal/runtime frames; showing the top internal frame so scopes and evaluate still work. Pass includeInternals: true to see the full stack.`
         : `${stackTrace.hiddenFrameCount} internal frame(s) hidden — pass includeInternals: true to see them.`);
     }
+    // Frames whose file is a label rather than an openable path (issue #655):
+    // say so once, so an agent does not feed them to get_source_context.
+    const unresolvedCount = stackTrace.frames.filter((frame) => frame.unresolvedSource).length;
+    if (unresolvedCount > 0) {
+      notes.push(
+        `${unresolvedCount} frame(s) are source-mapped to files not present on this host (unresolvedSource: true) — their file is a label, not an openable path; attach with adapterConfig.sourceMaps: false to see the generated .js paths instead.`
+      );
+    }
     if (notes.length > 0) {
       payload.note = notes.join(' ');
     }
diff --git a/src/server/tool-schemas.ts b/src/server/tool-schemas.ts
index 81572cf6..bf3132f9 100644
--- a/src/server/tool-schemas.ts
+++ b/src/server/tool-schemas.ts
@@ -202,7 +202,7 @@ export function buildToolDefinitions(options: BuildToolDefinitionsOptions): Tool
     { name: 'list_threads', description: 'List all threads in the debugged process', inputSchema: { type: 'object', properties: { sessionId: { type: 'string' } }, required: ['sessionId'] } },
     { name: 'get_variables', description: 'Get variables (scope is variablesReference: number). Responses are size-guarded: oversized values are cut (truncated:true) and very large scopes return a capped list with a truncation notice — pass names:[...] to fetch specific variables in full', inputSchema: { type: 'object', properties: { sessionId: { type: 'string' }, scope: { type: 'number', description: "The variablesReference number from a StackFrame or Variable" }, names: namesProp }, required: getVariablesRequired } },
     { name: 'get_local_variables', description: 'Get local variables for the shared inspection anchor. If the stopped thread is frameless, a sibling with policy-recognized user frames is preferred, adopted, and disclosed in anchorNote. A JavaScript frame with no Local/block scope returns empty with guidance instead of mislabeling Global bindings. Responses are size-guarded; pass names:[...] to fetch specific variables in full', inputSchema: { type: 'object', properties: { sessionId: { type: 'string' }, includeSpecial: { type: 'boolean', description: 'Include special/internal variables like this, __proto__, __builtins__, etc. Default: false' }, names: namesProp }, required: getLocalVariablesRequired } },
-    { name: 'get_stack_trace', description: 'Get stack trace. The response includes stopReason — why the session is paused. For an implicit frameless stopped thread, a sibling with policy-recognized user frames is preferred and adopted, with the switch disclosed in note. Internal/runtime frames are filtered by default; when any are hidden the response carries hiddenFrames and a note', inputSchema: { type: 'object', properties: { sessionId: { type: 'string' }, includeInternals: { type: 'boolean', description: 'Include internal/framework frames (e.g., Node.js internals). Default: false for cleaner output.' }, threadId: { type: 'number', description: 'Inspect this exact thread (ids from list_threads). Explicit selection is authoritative and is never silently switched' } }, required: ['sessionId'] } },
+    { name: 'get_stack_trace', description: 'Get stack trace. The response includes stopReason — why the session is paused. For an implicit frameless stopped thread, a sibling with policy-recognized user frames is preferred and adopted, with the switch disclosed in note. Internal/runtime frames are filtered by default; when any are hidden the response carries hiddenFrames and a note', inputSchema: { type: 'object', properties: { sessionId: { type: 'string' }, includeInternals: { type: 'boolean', description: 'Include internal/framework frames (e.g., Node.js internals, node_modules dependencies, async separators). Default: false for cleaner output.' }, threadId: { type: 'number', description: 'Inspect this exact thread (ids from list_threads). Explicit selection is authoritative and is never silently switched' } }, required: ['sessionId'] } },
     { name: 'get_scopes', description: 'Get scopes for a stack frame', inputSchema: { type: 'object', properties: { sessionId: { type: 'string' }, frameId: { type: 'number', description: "The ID of the stack frame from a stackTrace response" } }, required: ['sessionId', 'frameId'] } },
     { name: 'evaluate_expression', description: 'Evaluate expression in the current debug context. Without frameId, uses the same adopted top frame as stack and locals and discloses an automatic thread switch in anchorNote. Expressions can read and modify program state. Waits up to 30s by default', inputSchema: { type: 'object', properties: { sessionId: { type: 'string' }, expression: { type: 'string' }, frameId: { type: 'number', description: 'Optional authoritative stack frame ID from get_stack_trace. When provided, no automatic frame/thread selection occurs' }, timeout: { type: 'number', description: 'Max time (ms) to wait for the evaluation to complete (default: 30000, max: 600000). On expiry the request fails but the expression may keep executing in the debuggee. Note: your MCP client may enforce its own overall request timeout' } }, required: ['sessionId', 'expression'] } },
     { name: 'get_source_context', description: 'Get source context around a specific line in a file', inputSchema: { type: 'object', properties: { sessionId: { type: 'string' }, file: { type: 'string', description: fileDescription }, line: { type: 'number', description: 'Line number to get context for' }, linesContext: { type: 'number', description: 'Number of lines before and after to include (default: 5)' } }, required: ['sessionId', 'file', 'line'] } },
diff --git a/src/session/inspection/frame-anchor-resolver.ts b/src/session/inspection/frame-anchor-resolver.ts
index d1cd8f3c..7ddba9f7 100644
--- a/src/session/inspection/frame-anchor-resolver.ts
+++ b/src/session/inspection/frame-anchor-resolver.ts
@@ -108,13 +108,27 @@ export class FrameAnchorResolver {
         note = await this.describeFramelessThread(sessionId, proxyManager, threadId);
       }
 
-      let frames: StackFrame[] = rawFrames.map((frame) => ({
-        id: frame.id,
-        name: frame.name,
-        file: frame.source?.path || frame.source?.name || '<unknown_source>',
-        line: frame.line,
-        column: frame.column
-      }));
+      let frames: StackFrame[] = rawFrames.map((frame) => {
+        const file = frame.source?.path || frame.source?.name || '<unknown_source>';
+        // A non-zero sourceReference is the adapter saying "not a file you
+        // can open here" (js-debug sets it for every source it could not
+        // find on disk — a source-mapped '../src/x.ts' the package never
+        // shipped). Placeholder paths (<node_internals>, <eval>) carry one
+        // too but are self-describing, so only real-looking paths are
+        // flagged (issue #655).
+        const unresolvedSource =
+          typeof frame.source?.sourceReference === 'number' &&
+          frame.source.sourceReference !== 0 &&
+          !file.startsWith('<');
+        return {
+          id: frame.id,
+          name: frame.name,
+          file,
+          line: frame.line,
+          column: frame.column,
+          ...(unresolvedSource ? { unresolvedSource: true } : {})
+        };
+      });
       const totalFrameCount = frames.length;
       let allFramesInternal = false;
       const policy = this.ctx.selectPolicy(session.language);
diff --git a/tests/core/unit/server/__snapshots__/tool-list/bp-assert.va-explicit.container-true.json b/tests/core/unit/server/__snapshots__/tool-list/bp-assert.va-explicit.container-true.json
index 206266b3..6bacd719 100644
--- a/tests/core/unit/server/__snapshots__/tool-list/bp-assert.va-explicit.container-true.json
+++ b/tests/core/unit/server/__snapshots__/tool-list/bp-assert.va-explicit.container-true.json
@@ -548,7 +548,7 @@
             },
             "includeInternals": {
               "type": "boolean",
-              "description": "Include internal/framework frames (e.g., Node.js internals). Default: false for cleaner output."
+              "description": "Include internal/framework frames (e.g., Node.js internals, node_modules dependencies, async separators). Default: false for cleaner output."
             },
             "threadId": {
               "type": "number",
diff --git a/tests/core/unit/server/__snapshots__/tool-list/bp-assert.va-explicit.container-unset.json b/tests/core/unit/server/__snapshots__/tool-list/bp-assert.va-explicit.container-unset.json
index 9a07d2db..c3f5a550 100644
--- a/tests/core/unit/server/__snapshots__/tool-list/bp-assert.va-explicit.container-unset.json
+++ b/tests/core/unit/server/__snapshots__/tool-list/bp-assert.va-explicit.container-unset.json
@@ -548,7 +548,7 @@
             },
             "includeInternals": {
               "type": "boolean",
-              "description": "Include internal/framework frames (e.g., Node.js internals). Default: false for cleaner output."
+              "description": "Include internal/framework frames (e.g., Node.js internals, node_modules dependencies, async separators). Default: false for cleaner output."
             },
             "threadId": {
               "type": "number",
diff --git a/tests/core/unit/server/__snapshots__/tool-list/bp-assert.va-open.container-true.json b/tests/core/unit/server/__snapshots__/tool-list/bp-assert.va-open.container-true.json
index 39b0ff47..bacbff08 100644
--- a/tests/core/unit/server/__snapshots__/tool-list/bp-assert.va-open.container-true.json
+++ b/tests/core/unit/server/__snapshots__/tool-list/bp-assert.va-open.container-true.json
@@ -546,7 +546,7 @@
             },
             "includeInternals": {
               "type": "boolean",
-              "description": "Include internal/framework frames (e.g., Node.js internals). Default: false for cleaner output."
+              "description": "Include internal/framework frames (e.g., Node.js internals, node_modules dependencies, async separators). Default: false for cleaner output."
             },
             "threadId": {
               "type": "number",
diff --git a/tests/core/unit/server/__snapshots__/tool-list/bp-assert.va-open.container-unset.json b/tests/core/unit/server/__snapshots__/tool-list/bp-assert.va-open.container-unset.json
index 2cacb61a..1883b573 100644
--- a/tests/core/unit/server/__snapshots__/tool-list/bp-assert.va-open.container-unset.json
+++ b/tests/core/unit/server/__snapshots__/tool-list/bp-assert.va-open.container-unset.json
@@ -546,7 +546,7 @@
             },
             "includeInternals": {
               "type": "boolean",
-              "description": "Include internal/framework frames (e.g., Node.js internals). Default: false for cleaner output."
+              "description": "Include internal/framework frames (e.g., Node.js internals, node_modules dependencies, async separators). Default: false for cleaner output."
             },
             "threadId": {
               "type": "number",
diff --git a/tests/core/unit/server/__snapshots__/tool-list/bp-assert.va-unset.container-true.json b/tests/core/unit/server/__snapshots__/tool-list/bp-assert.va-unset.container-true.json
index 39b0ff47..bacbff08 100644
--- a/tests/core/unit/server/__snapshots__/tool-list/bp-assert.va-unset.container-true.json
+++ b/tests/core/unit/server/__snapshots__/tool-list/bp-assert.va-unset.container-true.json
@@ -546,7 +546,7 @@
             },
             "includeInternals": {
               "type": "boolean",
-              "description": "Include internal/framework frames (e.g., Node.js internals). Default: false for cleaner output."
+              "description": "Include internal/framework frames (e.g., Node.js internals, node_modules dependencies, async separators). Default: false for cleaner output."
             },
             "threadId": {
               "type": "number",
diff --git a/tests/core/unit/server/__snapshots__/tool-list/bp-assert.va-unset.container-unset.json b/tests/core/unit/server/__snapshots__/tool-list/bp-assert.va-unset.container-unset.json
index 2cacb61a..1883b573 100644
--- a/tests/core/unit/server/__snapshots__/tool-list/bp-assert.va-unset.container-unset.json
+++ b/tests/core/unit/server/__snapshots__/tool-list/bp-assert.va-unset.container-unset.json
@@ -546,7 +546,7 @@
             },
             "includeInternals": {
               "type": "boolean",
-              "description": "Include internal/framework frames (e.g., Node.js internals). Default: false for cleaner output."
+              "description": "Include internal/framework frames (e.g., Node.js internals, node_modules dependencies, async separators). Default: false for cleaner output."
             },
             "threadId": {
               "type": "number",
diff --git a/tests/core/unit/server/__snapshots__/tool-list/bp-content.va-explicit.container-true.json b/tests/core/unit/server/__snapshots__/tool-list/bp-content.va-explicit.container-true.json
index 47a34976..d95b9f38 100644
--- a/tests/core/unit/server/__snapshots__/tool-list/bp-content.va-explicit.container-true.json
+++ b/tests/core/unit/server/__snapshots__/tool-list/bp-content.va-explicit.container-true.json
@@ -558,7 +558,7 @@
             },
             "includeInternals": {
               "type": "boolean",
-              "description": "Include internal/framework frames (e.g., Node.js internals). Default: false for cleaner output."
+              "description": "Include internal/framework frames (e.g., Node.js internals, node_modules dependencies, async separators). Default: false for cleaner output."
             },
             "threadId": {
               "type": "number",
diff --git a/tests/core/unit/server/__snapshots__/tool-list/bp-content.va-explicit.container-unset.json b/tests/core/unit/server/__snapshots__/tool-list/bp-content.va-explicit.container-unset.json
index 6e44a2d9..338fba8f 100644
--- a/tests/core/unit/server/__snapshots__/tool-list/bp-content.va-explicit.container-unset.json
+++ b/tests/core/unit/server/__snapshots__/tool-list/bp-content.va-explicit.container-unset.json
@@ -558,7 +558,7 @@
             },
             "includeInternals": {
               "type": "boolean",
-              "description": "Include internal/framework frames (e.g., Node.js internals). Default: false for cleaner output."
+              "description": "Include internal/framework frames (e.g., Node.js internals, node_modules dependencies, async separators). Default: false for cleaner output."
             },
             "threadId": {
               "type": "number",
diff --git a/tests/core/unit/server/__snapshots__/tool-list/bp-content.va-open.container-true.json b/tests/core/unit/server/__snapshots__/tool-list/bp-content.va-open.container-true.json
index 96c72286..f0c59861 100644
--- a/tests/core/unit/server/__snapshots__/tool-list/bp-content.va-open.container-true.json
+++ b/tests/core/unit/server/__snapshots__/tool-list/bp-content.va-open.container-true.json
@@ -556,7 +556,7 @@
             },
             "includeInternals": {
               "type": "boolean",
-              "description": "Include internal/framework frames (e.g., Node.js internals). Default: false for cleaner output."
+              "description": "Include internal/framework frames (e.g., Node.js internals, node_modules dependencies, async separators). Default: false for cleaner output."
             },
             "threadId": {
               "type": "number",
diff --git a/tests/core/unit/server/__snapshots__/tool-list/bp-content.va-open.container-unset.json b/tests/core/unit/server/__snapshots__/tool-list/bp-content.va-open.container-unset.json
index 6428b6c7..10b805ce 100644
--- a/tests/core/unit/server/__snapshots__/tool-list/bp-content.va-open.container-unset.json
+++ b/tests/core/unit/server/__snapshots__/tool-list/bp-content.va-open.container-unset.json
@@ -556,7 +556,7 @@
             },
             "includeInternals": {
               "type": "boolean",
-              "description": "Include internal/framework frames (e.g., Node.js internals). Default: false for cleaner output."
+              "description": "Include internal/framework frames (e.g., Node.js internals, node_modules dependencies, async separators). Default: false for cleaner output."
             },
             "threadId": {
               "type": "number",
diff --git a/tests/core/unit/server/__snapshots__/tool-list/bp-content.va-unset.container-true.json b/tests/core/unit/server/__snapshots__/tool-list/bp-content.va-unset.container-true.json
index 96c72286..f0c59861 100644
--- a/tests/core/unit/server/__snapshots__/tool-list/bp-content.va-unset.container-true.json
+++ b/tests/core/unit/server/__snapshots__/tool-list/bp-content.va-unset.container-true.json
@@ -556,7 +556,7 @@
             },
             "includeInternals": {
               "type": "boolean",
-              "description": "Include internal/framework frames (e.g., Node.js internals). Default: false for cleaner output."
+              "description": "Include internal/framework frames (e.g., Node.js internals, node_modules dependencies, async separators). Default: false for cleaner output."
             },
             "threadId": {
               "type": "number",
diff --git a/tests/core/unit/server/__snapshots__/tool-list/bp-content.va-unset.container-unset.json b/tests/core/unit/server/__snapshots__/tool-list/bp-content.va-unset.container-unset.json
index 6428b6c7..10b805ce 100644
--- a/tests/core/unit/server/__snapshots__/tool-list/bp-content.va-unset.container-unset.json
+++ b/tests/core/unit/server/__snapshots__/tool-list/bp-content.va-unset.container-unset.json
@@ -556,7 +556,7 @@
             },
             "includeInternals": {
               "type": "boolean",
-              "description": "Include internal/framework frames (e.g., Node.js internals). Default: false for cleaner output."
+              "description": "Include internal/framework frames (e.g., Node.js internals, node_modules dependencies, async separators). Default: false for cleaner output."
             },
             "threadId": {
               "type": "number",
diff --git a/tests/core/unit/server/__snapshots__/tool-list/bp-line.va-explicit.container-true.json b/tests/core/unit/server/__snapshots__/tool-list/bp-line.va-explicit.container-true.json
index bf3b16ec..69a337b8 100644
--- a/tests/core/unit/server/__snapshots__/tool-list/bp-line.va-explicit.container-true.json
+++ b/tests/core/unit/server/__snapshots__/tool-list/bp-line.va-explicit.container-true.json
@@ -544,7 +544,7 @@
             },
             "includeInternals": {
               "type": "boolean",
-              "description": "Include internal/framework frames (e.g., Node.js internals). Default: false for cleaner output."
+              "description": "Include internal/framework frames (e.g., Node.js internals, node_modules dependencies, async separators). Default: false for cleaner output."
             },
             "threadId": {
               "type": "number",
diff --git a/tests/core/unit/server/__snapshots__/tool-list/bp-line.va-explicit.container-unset.json b/tests/core/unit/server/__snapshots__/tool-list/bp-line.va-explicit.container-unset.json
index 9a288123..fecc3a7a 100644
--- a/tests/core/unit/server/__snapshots__/tool-list/bp-line.va-explicit.container-unset.json
+++ b/tests/core/unit/server/__snapshots__/tool-list/bp-line.va-explicit.container-unset.json
@@ -544,7 +544,7 @@
             },
             "includeInternals": {
               "type": "boolean",
-              "description": "Include internal/framework frames (e.g., Node.js internals). Default: false for cleaner output."
+              "description": "Include internal/framework frames (e.g., Node.js internals, node_modules dependencies, async separators). Default: false for cleaner output."
             },
             "threadId": {
               "type": "number",
diff --git a/tests/core/unit/server/__snapshots__/tool-list/bp-line.va-open.container-true.json b/tests/core/unit/server/__snapshots__/tool-list/bp-line.va-open.container-true.json
index aa9b1dfa..91753246 100644
--- a/tests/core/unit/server/__snapshots__/tool-list/bp-line.va-open.container-true.json
+++ b/tests/core/unit/server/__snapshots__/tool-list/bp-line.va-open.container-true.json
@@ -542,7 +542,7 @@
             },
             "includeInternals": {
               "type": "boolean",
-              "description": "Include internal/framework frames (e.g., Node.js internals). Default: false for cleaner output."
+              "description": "Include internal/framework frames (e.g., Node.js internals, node_modules dependencies, async separators). Default: false for cleaner output."
             },
             "threadId": {
               "type": "number",
diff --git a/tests/core/unit/server/__snapshots__/tool-list/bp-line.va-open.container-unset.json b/tests/core/unit/server/__snapshots__/tool-list/bp-line.va-open.container-unset.json
index 32276d0d..b3320cea 100644
--- a/tests/core/unit/server/__snapshots__/tool-list/bp-line.va-open.container-unset.json
+++ b/tests/core/unit/server/__snapshots__/tool-list/bp-line.va-open.container-unset.json
@@ -542,7 +542,7 @@
             },
             "includeInternals": {
               "type": "boolean",
-              "description": "Include internal/framework frames (e.g., Node.js internals). Default: false for cleaner output."
+              "description": "Include internal/framework frames (e.g., Node.js internals, node_modules dependencies, async separators). Default: false for cleaner output."
             },
             "threadId": {
               "type": "number",
diff --git a/tests/core/unit/server/__snapshots__/tool-list/bp-line.va-unset.container-true.json b/tests/core/unit/server/__snapshots__/tool-list/bp-line.va-unset.container-true.json
index aa9b1dfa..91753246 100644
--- a/tests/core/unit/server/__snapshots__/tool-list/bp-line.va-unset.container-true.json
+++ b/tests/core/unit/server/__snapshots__/tool-list/bp-line.va-unset.container-true.json
@@ -542,7 +542,7 @@
             },
             "includeInternals": {
               "type": "boolean",
-              "description": "Include internal/framework frames (e.g., Node.js internals). Default: false for cleaner output."
+              "description": "Include internal/framework frames (e.g., Node.js internals, node_modules dependencies, async separators). Default: false for cleaner output."
             },
             "threadId": {
               "type": "number",
diff --git a/tests/core/unit/server/__snapshots__/tool-list/bp-line.va-unset.container-unset.json b/tests/core/unit/server/__snapshots__/tool-list/bp-line.va-unset.container-unset.json
index 32276d0d..b3320cea 100644
--- a/tests/core/unit/server/__snapshots__/tool-list/bp-line.va-unset.container-unset.json
+++ b/tests/core/unit/server/__snapshots__/tool-list/bp-line.va-unset.container-unset.json
@@ -542,7 +542,7 @@
             },
             "includeInternals": {
               "type": "boolean",
-              "description": "Include internal/framework frames (e.g., Node.js internals). Default: false for cleaner output."
+              "description": "Include internal/framework frames (e.g., Node.js internals, node_modules dependencies, async separators). Default: false for cleaner output."
             },
             "threadId": {
               "type": "number",
diff --git a/tests/core/unit/server/__snapshots__/tool-list/bp-unset.va-explicit.container-true.json b/tests/core/unit/server/__snapshots__/tool-list/bp-unset.va-explicit.container-true.json
index 47a34976..d95b9f38 100644
--- a/tests/core/unit/server/__snapshots__/tool-list/bp-unset.va-explicit.container-true.json
+++ b/tests/core/unit/server/__snapshots__/tool-list/bp-unset.va-explicit.container-true.json
@@ -558,7 +558,7 @@
             },
             "includeInternals": {
               "type": "boolean",
-              "description": "Include internal/framework frames (e.g., Node.js internals). Default: false for cleaner output."
+              "description": "Include internal/framework frames (e.g., Node.js internals, node_modules dependencies, async separators). Default: false for cleaner output."
             },
             "threadId": {
               "type": "number",
diff --git a/tests/core/unit/server/__snapshots__/tool-list/bp-unset.va-explicit.container-unset.json b/tests/core/unit/server/__snapshots__/tool-list/bp-unset.va-explicit.container-unset.json
index 6e44a2d9..338fba8f 100644
--- a/tests/core/unit/server/__snapshots__/tool-list/bp-unset.va-explicit.container-unset.json
+++ b/tests/core/unit/server/__snapshots__/tool-list/bp-unset.va-explicit.container-unset.json
@@ -558,7 +558,7 @@
             },
             "includeInternals": {
               "type": "boolean",
-              "description": "Include internal/framework frames (e.g., Node.js internals). Default: false for cleaner output."
+              "description": "Include internal/framework frames (e.g., Node.js internals, node_modules dependencies, async separators). Default: false for cleaner output."
             },
             "threadId": {
               "type": "number",
diff --git a/tests/core/unit/server/__snapshots__/tool-list/bp-unset.va-open.container-true.json b/tests/core/unit/server/__snapshots__/tool-list/bp-unset.va-open.container-true.json
index 96c72286..f0c59861 100644
--- a/tests/core/unit/server/__snapshots__/tool-list/bp-unset.va-open.container-true.json
+++ b/tests/core/unit/server/__snapshots__/tool-list/bp-unset.va-open.container-true.json
@@ -556,7 +556,7 @@
             },
             "includeInternals": {
               "type": "boolean",
-              "description": "Include internal/framework frames (e.g., Node.js internals). Default: false for cleaner output."
+              "description": "Include internal/framework frames (e.g., Node.js internals, node_modules dependencies, async separators). Default: false for cleaner output."
             },
             "threadId": {
               "type": "number",
diff --git a/tests/core/unit/server/__snapshots__/tool-list/bp-unset.va-open.container-unset.json b/tests/core/unit/server/__snapshots__/tool-list/bp-unset.va-open.container-unset.json
index 6428b6c7..10b805ce 100644
--- a/tests/core/unit/server/__snapshots__/tool-list/bp-unset.va-open.container-unset.json
+++ b/tests/core/unit/server/__snapshots__/tool-list/bp-unset.va-open.container-unset.json
@@ -556,7 +556,7 @@
             },
             "includeInternals": {
               "type": "boolean",
-              "description": "Include internal/framework frames (e.g., Node.js internals). Default: false for cleaner output."
+              "description": "Include internal/framework frames (e.g., Node.js internals, node_modules dependencies, async separators). Default: false for cleaner output."
             },
             "threadId": {
               "type": "number",
diff --git a/tests/core/unit/server/__snapshots__/tool-list/bp-unset.va-unset.container-true.json b/tests/core/unit/server/__snapshots__/tool-list/bp-unset.va-unset.container-true.json
index 96c72286..f0c59861 100644
--- a/tests/core/unit/server/__snapshots__/tool-list/bp-unset.va-unset.container-true.json
+++ b/tests/core/unit/server/__snapshots__/tool-list/bp-unset.va-unset.container-true.json
@@ -556,7 +556,7 @@
             },
             "includeInternals": {
               "type": "boolean",
-              "description": "Include internal/framework frames (e.g., Node.js internals). Default: false for cleaner output."
+              "description": "Include internal/framework frames (e.g., Node.js internals, node_modules dependencies, async separators). Default: false for cleaner output."
             },
             "threadId": {
               "type": "number",
diff --git a/tests/core/unit/server/__snapshots__/tool-list/bp-unset.va-unset.container-unset.json b/tests/core/unit/server/__snapshots__/tool-list/bp-unset.va-unset.container-unset.json
index 6428b6c7..10b805ce 100644
--- a/tests/core/unit/server/__snapshots__/tool-list/bp-unset.va-unset.container-unset.json
+++ b/tests/core/unit/server/__snapshots__/tool-list/bp-unset.va-unset.container-unset.json
@@ -556,7 +556,7 @@
             },
             "includeInternals": {
               "type": "boolean",
-              "description": "Include internal/framework frames (e.g., Node.js internals). Default: false for cleaner output."
+              "description": "Include internal/framework frames (e.g., Node.js internals, node_modules dependencies, async separators). Default: false for cleaner output."
             },
             "threadId": {
               "type": "number",
diff --git a/tests/core/unit/server/server-inspection-tools.test.ts b/tests/core/unit/server/server-inspection-tools.test.ts
index b23c63fe..2d47ad15 100644
--- a/tests/core/unit/server/server-inspection-tools.test.ts
+++ b/tests/core/unit/server/server-inspection-tools.test.ts
@@ -258,6 +258,32 @@ describe('Server Inspection Tools Tests', () => {
       expect(content.note).toContain('includeInternals: true');
     });
 
+    it('notes frames whose file is a source-map label rather than an openable path (issue #655)', async () => {
+      const mockSession = {
+        proxyManager: { getCurrentThreadId: vi.fn().mockReturnValue(1) }
+      };
+      mockSessionManager.getSession.mockReturnValue(mockSession);
+      mockSessionManager.getStackTraceDetailed.mockResolvedValue({
+        frames: [
+          { id: 1, name: 'jsonResult', file: '/app/dist/tool-result.js', line: 13 },
+          { id: 2, name: 'handler', file: '../src/handlers/tools.ts', line: 89, unresolvedSource: true }
+        ],
+        totalFrameCount: 2, hiddenFrameCount: 0, allFramesInternal: false
+      });
+
+      const result = await callToolHandler({
+        method: 'tools/call',
+        params: { name: 'get_stack_trace', arguments: { sessionId: 'test-session' } }
+      });
+
+      const content = JSON.parse(result.content[0].text);
+      expect(content.success).toBe(true);
+      expect(content.hiddenFrames).toBeUndefined();
+      expect(content.stackFrames[1].unresolvedSource).toBe(true);
+      expect(content.note).toContain('1 frame(s) are source-mapped to files not present on this host');
+      expect(content.note).toContain('adapterConfig.sourceMaps: false');
+    });
+
     it('explains the kept-first-frame fallback when every frame is internal (issue #346)', async () => {
       const mockSession = {
         proxyManager: { getCurrentThreadId: vi.fn().mockReturnValue(1) }
diff --git a/tests/core/unit/session/session-manager-dap.test.ts b/tests/core/unit/session/session-manager-dap.test.ts
index 40631f70..6d36809c 100644
--- a/tests/core/unit/session/session-manager-dap.test.ts
+++ b/tests/core/unit/session/session-manager-dap.test.ts
@@ -2206,6 +2206,54 @@ describe('SessionManager - DAP Operations', () => {
       expect(frames).toHaveLength(1);
     });
 
+    it('js attach stack (issue #655): node_modules and async separators hidden, phantom source-mapped frames flagged', async () => {
+      // The shape js-debug returned for an attached express/MCP server:
+      // one user frame, pnpm dependency frames, `await` separators (no
+      // source, line 0, presentationHint label), a source-mapped '.ts' the
+      // package never shipped (sourceReference != 0), and node internals.
+      const JS_FRAMES = [
+        { id: 1, name: 'jsonResult', line: 13, source: { path: '/app/dist/server/tool-result.js', sourceReference: 0 } },
+        { id: 2, name: 'handleRequest', line: 89, source: { path: '../src/server/handlers/language-tools.ts', sourceReference: 253482918 } },
+        { id: 3, name: 'processTicksAndRejections', line: 103, source: { path: '<node_internals>/internal/process/task_queues', sourceReference: 1090918982 } },
+        { id: 4, name: 'await', line: 0, column: 0, presentationHint: 'label' },
+        { id: 5, name: 'handle', line: 435, source: { path: '/app/node_modules/.pnpm/router@2.2.0/node_modules/router/index.js', sourceReference: 0 } },
+        { id: 6, name: 'HTTPINCOMINGMESSAGE', line: 0, column: 0, presentationHint: 'label' }
+      ];
+      const session = await pausedSessionWithFrames(JS_FRAMES);
+      (sessionManager as unknown as { selectPolicy: () => unknown }).selectPolicy = () => JsDebugAdapterPolicy;
+
+      const result = await sessionManager.getStackTraceDetailed(session.id);
+
+      expect(result.frames.map((f) => f.name)).toEqual(['jsonResult', 'handleRequest']);
+      expect(result.totalFrameCount).toBe(6);
+      expect(result.hiddenFrameCount).toBe(4);
+      expect(result.allFramesInternal).toBe(false);
+      expect(result.frames[0].unresolvedSource).toBeUndefined();
+      expect(result.frames[1]).toMatchObject({ file: '../src/server/handlers/language-tools.ts', unresolvedSource: true });
+
+      const unfiltered = await sessionManager.getStackTraceDetailed(session.id, undefined, true);
+      expect(unfiltered.frames).toHaveLength(6);
+      // Placeholder paths are self-describing: not flagged even with a sourceReference.
+      expect(unfiltered.frames[2]).not.toHaveProperty('unresolvedSource');
+      expect(unfiltered.frames[3].file).toBe('<unknown_source>');
+    });
+
+    it('all-internal js stack (issue #655): the central fallback engages now that the policy has no local one', async () => {
+      const ALL_INTERNAL = [
+        { id: 1, name: 'processTimers', line: 507, source: { path: '<node_internals>/internal/timers', sourceReference: 7 } },
+        { id: 2, name: 'next', line: 291, source: { path: '/app/node_modules/router/index.js', sourceReference: 0 } }
+      ];
+      const session = await pausedSessionWithFrames(ALL_INTERNAL);
+      (sessionManager as unknown as { selectPolicy: () => unknown }).selectPolicy = () => JsDebugAdapterPolicy;
+
+      const result = await sessionManager.getStackTraceDetailed(session.id);
+
+      expect(result.frames).toHaveLength(1);
+      expect(result.frames[0].name).toBe('processTimers');
+      expect(result.hiddenFrameCount).toBe(1);
+      expect(result.allFramesInternal).toBe(true);
+    });
+
     it('all-internal LLDB stack (issue #369): rust policy filter engages, first-frame fallback annotates', async () => {
       // A rust program paused inside a sleep: every frame is LLDB/libc
       // internal. The real RustAdapterPolicy must classify them all as
diff --git a/tests/unit/shared/adapter-policy-js.test.ts b/tests/unit/shared/adapter-policy-js.test.ts
index d6b617e2..55423447 100644
--- a/tests/unit/shared/adapter-policy-js.test.ts
+++ b/tests/unit/shared/adapter-policy-js.test.ts
@@ -61,12 +61,17 @@ describe('JsDebugAdapterPolicy', () => {
       { id: 3, file: '<node_internals>/inspector' }
     ];
 
+    // Issue #655: node_modules dependency frames are internal too.
     const filtered = JsDebugAdapterPolicy.filterStackFrames(frames as any, false);
-    expect(filtered).toHaveLength(2);
-    expect(filtered.find(frame => String(frame.file).includes('<node_internals>'))).toBeUndefined();
+    expect(filtered).toHaveLength(1);
+    expect(filtered[0].file).toBe('/app/index.js');
 
     const includeAll = JsDebugAdapterPolicy.filterStackFrames(frames as any, true);
     expect(includeAll).toHaveLength(3);
+
+    // No local fallback: an all-internal stack filters to [] and the
+    // session-layer resolver restores the top frame (issue #346).
+    expect(JsDebugAdapterPolicy.filterStackFrames!(frames.slice(1) as any, false)).toEqual([]);
   });
 
   it('extracts local variables while excluding special entries', () => {
@@ -420,6 +425,19 @@ describe('JsDebugAdapterPolicy', () => {
         autoAttachChildProcesses: true
       });
       expect(optedIn.autoAttachChildProcesses).toBe(true);
+
+      // Issue #655: the same self-containment for resolveSourceMapLocations.
+      expect(defaulted.resolveSourceMapLocations).toEqual(['**', '!**/node_modules/**']);
+      const callerList = await runAttachHandshake({
+        request: 'attach', attachSimplePort: 9229, type: 'pwa-node',
+        resolveSourceMapLocations: ['/app/**']
+      });
+      expect(callerList.resolveSourceMapLocations).toEqual(['/app/**']);
+      const callerNull = await runAttachHandshake({
+        request: 'attach', attachSimplePort: 9229, type: 'pwa-node',
+        resolveSourceMapLocations: null
+      });
+      expect(callerNull.resolveSourceMapLocations).toBeNull();
     });
   });
 });