From f6efab7ecba9bd2d1eb6d5632618d528588dcfbe Mon Sep 17 00:00:00 2001
From: JF <john.franklin@gmail.com>
Date: Thu, 5 Nov 2026 19:15:32 -0500
Subject: [PATCH 1/6] feat(session-tree): a js-debug fork reported after the
 program is a child session (#1082)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

M2 of the session tree, first slice: with `autoAttachChildProcesses: true`
every process js-debug reports after the program's own target — a fork, a
spawn of process.execPath, a cluster worker, a grandchild — is adopted
through the M1 mechanism as a child debug session instead of being released
to run undebugged (#501).

The rule: in a js-debug worker the root connection's first report is the
program, adopted in-session by ChildSessionManager as before (the #704
launch-ready signal); every other report, on any connection, is a child
report held by ChildConnections. Every non-root connection runs the
child-safe policy, so no connection but the root ever builds a manager.

- The adoption contract gains `readChildReport` (report recognition) and a
  root config for `buildChildAttachArguments`; js-debug pins
  `throwaway-attach` / `launch-session` / `release` with the measured attach
  body (`{ type, request: 'attach', __pendingTargetId, continueOnAttach }`,
  an attach root's forwardable extras riding along, #466). The js policy's
  `handleReverseRequest` adopts the first pending target in-session and
  hands every later one up as a child report, unanswered.
- `createChildSafePolicy` moves to its own module: for a contract policy it
  reads every report through the contract and never adopts in-session; the
  manager's forward-to-release path goes with it. The program target's
  initialize advertises `supportsStartDebuggingRequest` too.
- A fork is reported on the program target's connection: the manager relays
  the held request as `childReport`, naming that connection, and
  MinimalDapClient hands it to the root's holder (`child-report` now carries
  the origin client, which is where the answer goes).
- The throwaway lever in ChildConnections: a js-debug report is acked the
  moment it is held (measured: the answer decides nothing; refusing parks the
  child forever) and never answered again; release opens a fresh child-safe
  connection and runs the #501 sequence (`src/proxy/throwaway-release.ts`:
  initialize → configurationDone → attach → ready signal → disconnect with
  the target kept, capped 20 s). A process the released child reports in
  that window is held on the session the released child was reported on.
- `childOutput: 'launch-session'` gets its consumer: a js child's
  `get_output` and output resource answer `outputOn: <root id>` with a note,
  since the tree's output arrives on the launch session's connection only.
- `closeChild: 'release'` now shapes the close itself: a js child's
  connection closes with `terminateDebuggee: false` (measured no-op either
  way; the flag matches the answer `released: true`), in the root's cascade
  as well.
- The contract test pins js-debug's contract and allows the one policy whose
  program is itself a pending target to combine it with in-session adoption,
  with per-engine report fixtures.

`ChildSessionManager.releaseUndebugged` is unreachable for js-debug after
this and stays as the manager's own invariant; its removal is a follow-up.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_015BDrn6AsHQ4rmTXFHzQkn8
---
 .../src/interfaces/adapter-policy-js.ts       | 154 ++++++++++----
 .../src/interfaces/adapter-policy-python.ts   |   3 +-
 .../shared/src/interfaces/adapter-policy.ts   |   7 +-
 .../shared/src/interfaces/child-adoption.ts   |  27 ++-
 src/proxy/child-connections.ts                | 116 +++++++++--
 src/proxy/child-safe-policy.ts                |  68 ++++++
 src/proxy/child-session-manager.ts            |  78 ++-----
 src/proxy/minimal-dap.ts                      |  43 +++-
 src/proxy/throwaway-release.ts                | 118 +++++++++++
 src/server/handlers/output-tools.ts           |  12 +-
 src/server/output-resources.ts                |   8 +-
 src/session/session-manager-core.ts           |  31 ++-
 .../server/server-inspection-tools.test.ts    |  29 +++
 tests/core/unit/server/server-test-helpers.ts |   2 +
 .../session-manager-child-sessions.test.ts    |  58 +++++-
 tests/proxy/child-connections.test.ts         | 196 +++++++++++++++++-
 tests/proxy/child-session-manager.test.ts     |  89 ++++----
 .../dap-proxy-worker-child-sessions.test.ts   |  24 ++-
 .../dap-proxy-connection-manager.test.ts      |  14 +-
 tests/unit/proxy/minimal-dap.test.ts          |  28 ++-
 tests/unit/proxy/throwaway-release.test.ts    |  93 +++++++++
 .../shared/adapter-policy-contract.test.ts    |  97 +++++++--
 tests/unit/shared/adapter-policy-js.test.ts   |  80 +++++++
 23 files changed, 1161 insertions(+), 214 deletions(-)
 create mode 100644 src/proxy/child-safe-policy.ts
 create mode 100644 src/proxy/throwaway-release.ts
 create mode 100644 tests/unit/proxy/throwaway-release.test.ts

diff --git a/packages/shared/src/interfaces/adapter-policy-js.ts b/packages/shared/src/interfaces/adapter-policy-js.ts
index 4b91a986e..501e56a8b 100644
--- a/packages/shared/src/interfaces/adapter-policy-js.ts
+++ b/packages/shared/src/interfaces/adapter-policy-js.ts
@@ -20,6 +20,7 @@ import type { StackFrame, Variable } from '../models/index.js';
 import { toSourceBreakpoint, type BreakpointFields } from '../utils/to-source-breakpoint.js';
 import { compileJsLogpoint, validateJsLogpoint } from '../utils/js-logpoint.js';
 import type { DapClientBehavior, DapClientContext, ReverseRequestResult } from './dap-client-behavior.js';
+import type { ChildAdoptionContract, ChildReport } from './child-adoption.js';
 
 /**
  * Every js-debug scope name this adapter knows, grouped by kind.
@@ -119,6 +120,100 @@ function hasNoSource(filePath: string): boolean {
   return filePath === '' || filePath === '<unknown_source>';
 }
 
+/**
+ * The attach a connection sends to adopt one of js-debug's pending targets —
+ * the program's own (the launch session's single in-session child) and, with
+ * the session tree, every fork after it (issue #1082).
+ */
+function buildJsChildStartArgs(
+  pendingId: string,
+  parentConfig: Record<string, unknown>,
+  attachArguments?: Readonly<Record<string, unknown>>
+): { command: 'launch' | 'attach'; args: Record<string, unknown> } {
+  // js-debug's reverse-request values take precedence over parent extras.
+  // Our request/stopOnEntry intent never enters either adapter argument bag.
+  const config = { ...attachArguments, ...parentConfig };
+  const type = typeof config.type === 'string' ? config.type : 'pwa-node';
+  // Carry the parent's forwardable attach extras (localRoot/remoteRoot,
+  // sourceMaps, skipFiles, …) into the child — source resolution happens
+  // here, so this is where they take effect (issue #466). The orchestration
+  // keys stay pinned/excluded: address/port/attachSimplePort would make the
+  // child a second direct attach to the same inspector (the #124
+  // fight-over-the-process failure). These are adapter connection fields,
+  // not a deny-list of our start-intent fields (issue #730).
+  const {
+    name: _name,
+    __pendingTargetId: _pendingTargetId,
+    host: _host,
+    address: _address,
+    port: _port,
+    attachSimplePort: _attachSimplePort,
+    attachExistingChildren: _attachExistingChildren,
+    continueOnAttach: _continueOnAttach,
+    type: _type,
+    ...parentExtras
+  } = config;
+  void _name; void _pendingTargetId; void _host; void _address;
+  void _port; void _attachSimplePort; void _attachExistingChildren;
+  void _continueOnAttach; void _type;
+  return {
+    command: 'attach',
+    args: {
+      ...parentExtras,
+      type,
+      request: 'attach',
+      __pendingTargetId: pendingId,
+      continueOnAttach: true  // js-debug requires true to work properly
+    }
+  };
+}
+
+/**
+ * A js-debug process report (issue #1082): a `startDebugging` whose
+ * configuration carries a `__pendingTargetId` — the program itself on the
+ * root connection, a fork or a cluster worker on the program's connection, a
+ * grandchild on the fork's (docs/javascript/spike-notes-forks.md). The
+ * request says `request: "launch"` whatever the adoption is; `name` is
+ * `<script> [<pid>]`, the only hint at what the process is.
+ */
+function readJsDebugChildReport(request: DebugProtocol.Request): ChildReport | undefined {
+  if (request.command !== 'startDebugging') {
+    return undefined;
+  }
+  const args = (request.arguments ?? {}) as { configuration?: unknown };
+  const configuration = args.configuration;
+  if (typeof configuration !== 'object' || configuration === null) {
+    return undefined;
+  }
+  const { __pendingTargetId: pendingId, name } = configuration as { __pendingTargetId?: unknown; name?: unknown };
+  if (typeof pendingId !== 'string' || pendingId.length === 0) {
+    return undefined;
+  }
+  return {
+    targetId: pendingId,
+    name: typeof name === 'string' && name.length > 0 ? name : `target ${pendingId.slice(0, 8)}`,
+    configuration: configuration as Record<string, unknown>
+  };
+}
+
+/** js-debug's pins for the session tree (docs/architecture/session-tree.md, the adapter survey; issue #1082). */
+const jsDebugChildAdoption: ChildAdoptionContract = {
+  // Every connection asks for the request form; js-debug reports on each regardless.
+  advertiseStartDebugging: true,
+  // Rejecting a report parks the child forever (measured); a throwaway
+  // attach-then-detach is the only release (#501).
+  releaseLever: 'throwaway-attach',
+  // The whole tree's output arrives on the root connection; child connections carry none.
+  childOutput: 'launch-session',
+  // `disconnect` on a fork, with either flag, leaves it running (measured).
+  closeChild: 'release',
+  readChildReport: readJsDebugChildReport,
+  // The measured second-connection attach; an attach root's forwardable
+  // extras (localRoot/remoteRoot, sourceMaps, skipFiles, #466) ride along.
+  buildChildAttachArguments: (report: ChildReport, rootConfig?: Readonly<Record<string, unknown>>): Record<string, unknown> =>
+    buildJsChildStartArgs(report.targetId, report.configuration, rootConfig?.request === 'attach' ? rootConfig : undefined).args
+};
+
 export const JsDebugAdapterPolicy = {
   name: 'js-debug',
   supportsLogPoints: true,
@@ -163,48 +258,10 @@ export const JsDebugAdapterPolicy = {
   honoursNoDebug: true,
   supportsReverseStartDebugging: true,
   childSessionStrategy: 'launchWithPendingTarget',
-  buildChildStartArgs: (
-    pendingId: string,
-    parentConfig: Record<string, unknown>,
-    attachArguments?: Readonly<Record<string, unknown>>
-  ) => {
-    // js-debug's reverse-request values take precedence over parent extras.
-    // Our request/stopOnEntry intent never enters either adapter argument bag.
-    const config = { ...attachArguments, ...parentConfig };
-    const type = typeof config.type === 'string' ? config.type : 'pwa-node';
-    // Carry the parent's forwardable attach extras (localRoot/remoteRoot,
-    // sourceMaps, skipFiles, …) into the child — source resolution happens
-    // here, so this is where they take effect (issue #466). The orchestration
-    // keys stay pinned/excluded: address/port/attachSimplePort would make the
-    // child a second direct attach to the same inspector (the #124
-    // fight-over-the-process failure). These are adapter connection fields,
-    // not a deny-list of our start-intent fields (issue #730).
-    const {
-      name: _name,
-      __pendingTargetId: _pendingTargetId,
-      host: _host,
-      address: _address,
-      port: _port,
-      attachSimplePort: _attachSimplePort,
-      attachExistingChildren: _attachExistingChildren,
-      continueOnAttach: _continueOnAttach,
-      type: _type,
-      ...parentExtras
-    } = config;
-    void _name; void _pendingTargetId; void _host; void _address;
-    void _port; void _attachSimplePort; void _attachExistingChildren;
-    void _continueOnAttach; void _type;
-    return {
-      command: 'attach',
-      args: {
-        ...parentExtras,
-        type,
-        request: 'attach',
-        __pendingTargetId: pendingId,
-        continueOnAttach: true  // js-debug requires true to work properly
-      }
-    };
-  },
+  // The session tree (issue #1082): every report after the program's own is a
+  // child session on a fresh connection, released by a throwaway attach.
+  childAdoption: jsDebugChildAdoption,
+  buildChildStartArgs: buildJsChildStartArgs,
   isChildReadyEvent: (evt: DebugProtocol.Event): boolean => {
     // js-debug often signals readiness by posting a 'thread' event or an early 'stopped'.
     // Waiting on these ensures threads() will not be empty.
@@ -1226,11 +1283,22 @@ export const JsDebugAdapterPolicy = {
       // Handle reverse startDebugging requests
       handleReverseRequest: async (request: DebugProtocol.Request, context: DapClientContext): Promise<ReverseRequestResult> => {
         if (request.command === 'startDebugging') {
+          // The session tree (issue #1082): the first pending target on this
+          // connection is the program itself, adopted in-session below; every
+          // later one is a child the debuggee started, handed to the worker
+          // unanswered (the held report is acked there, and resolved only by
+          // a connection attaching with its id, or a throwaway one releasing it).
+          if (context.adoptedTargets.size > 0) {
+            const childReport = jsDebugChildAdoption.readChildReport(request);
+            if (childReport && !context.adoptedTargets.has(childReport.targetId)) {
+              return { handled: true, childReport };
+            }
+          }
           // eslint-disable-next-line @typescript-eslint/no-explicit-any
           const args: any = (request as any)?.arguments ?? {};
           const cfg = args?.configuration ?? {};
           const pendingId: string | undefined = cfg?.__pendingTargetId;
-          
+
           // Send acknowledgment. The early success ack is correct: js-debug
           // ignores the response body — a pending target is resolved only by
           // a fresh DAP connection attaching with its __pendingTargetId.
diff --git a/packages/shared/src/interfaces/adapter-policy-python.ts b/packages/shared/src/interfaces/adapter-policy-python.ts
index a4bd60b1e..205883d8a 100644
--- a/packages/shared/src/interfaces/adapter-policy-python.ts
+++ b/packages/shared/src/interfaces/adapter-policy-python.ts
@@ -47,6 +47,7 @@ const pythonChildAdoption: ChildAdoptionContract = {
   childOutput: 'own-connection',
   // `disconnect { terminateDebuggee: true }` on the child ends it (exit 0 reported to the parent).
   closeChild: 'terminate',
+  readChildReport: readDebugpyChildReport,
   buildChildAttachArguments: (report: ChildReport): Record<string, unknown> => ({
     ...report.configuration,
     redirectOutput: true
@@ -352,7 +353,7 @@ export const PythonAdapterPolicy = {
           context.sendResponse(request, {});
           return { handled: true };
         }
-        const childReport = readDebugpyChildReport(request);
+        const childReport = pythonChildAdoption.readChildReport(request);
         if (childReport) {
           // No response here: the worker holds the request until the server
           // adopts the child (success) or releases it (failure, which makes
diff --git a/packages/shared/src/interfaces/adapter-policy.ts b/packages/shared/src/interfaces/adapter-policy.ts
index a6debbd1c..6f7af1af5 100644
--- a/packages/shared/src/interfaces/adapter-policy.ts
+++ b/packages/shared/src/interfaces/adapter-policy.ts
@@ -498,9 +498,10 @@ export interface AdapterPolicy {
   /**
    * The session-tree adoption contract (issue #1081): defined by an adapter that
    * reports the processes its debuggee starts, so each becomes a child debug
-   * session of the reporting one. Undefined for adapters that report nothing;
-   * never combined with `supportsReverseStartDebugging` (the js-shaped
-   * single-target adoption of the program itself).
+   * session of the reporting one. Undefined for adapters that report nothing.
+   * Combined with `supportsReverseStartDebugging` only by js-debug (issue
+   * #1082), whose program is itself the first pending target, adopted
+   * in-session; every report after it is a child of this contract.
    */
   childAdoption?: ChildAdoptionContract;
 
diff --git a/packages/shared/src/interfaces/child-adoption.ts b/packages/shared/src/interfaces/child-adoption.ts
index 04dad58f6..a9fd334a6 100644
--- a/packages/shared/src/interfaces/child-adoption.ts
+++ b/packages/shared/src/interfaces/child-adoption.ts
@@ -8,7 +8,13 @@
  * `supportsStartDebuggingRequest`. Two of this server's engines implement it
  * (debugpy, js-debug); the rest keep `attach_to_process` as the route to a
  * child and leave the contract undefined. See docs/architecture/session-tree.md.
+ *
+ * js-debug (issue #1082) is the one engine whose program is itself a pending
+ * target: its first report on the root connection is the program, adopted
+ * in-session (`childSessionStrategy: 'launchWithPendingTarget'`); every later
+ * report, on any connection, is a child of this contract.
  */
+import type { DebugProtocol } from '@vscode/debugprotocol';
 
 /** One reported child, as the policy read it off the adapter's request. */
 export interface ChildReport {
@@ -30,7 +36,10 @@ export interface ChildAdoptionContract {
   /**
    * What releases a reported child the server will not adopt: answering the
    * request `success: false` (debugpy unblocks the child itself), or a
-   * throwaway attach-then-detach (js-debug parks a refused child forever).
+   * throwaway attach-then-detach (js-debug parks a refused child forever —
+   * its report is answered `{}` the moment it is held, which neither adopts
+   * nor releases, and only a connection attaching with the target's id
+   * resolves it).
    */
   releaseLever: 'reject-request' | 'throwaway-attach';
   /**
@@ -43,6 +52,18 @@ export interface ChildAdoptionContract {
    * debugpy terminates it; js-debug can only release it to run undebugged.
    */
   closeChild: 'terminate' | 'release';
-  /** The `attach` arguments for the child's own connection, built from the report. */
-  buildChildAttachArguments(report: ChildReport): Record<string, unknown>;
+  /**
+   * Report recognition: the child a `startDebugging` request names, or
+   * undefined for a request that is not a child report of this adapter
+   * (debugpy: `request: 'attach'` with a numeric `subProcessId`; js-debug: a
+   * string `__pendingTargetId`).
+   */
+  readChildReport(request: DebugProtocol.Request): ChildReport | undefined;
+  /**
+   * The `attach` arguments for the child's own connection, built from the
+   * report; `rootConfig` is the root session's launch or attach configuration,
+   * for the extras an adapter forwards from the root to each child (js-debug's
+   * `localRoot`/`remoteRoot`, `sourceMaps`, `skipFiles` on an attach root, #466).
+   */
+  buildChildAttachArguments(report: ChildReport, rootConfig?: Readonly<Record<string, unknown>>): Record<string, unknown>;
 }
diff --git a/src/proxy/child-connections.ts b/src/proxy/child-connections.ts
index 4301a98ad..4c7746fd8 100644
--- a/src/proxy/child-connections.ts
+++ b/src/proxy/child-connections.ts
@@ -8,19 +8,24 @@
  * report is held unanswered here while the parent process decides, then
  * adopted — a fresh connection to the same adapter, the child handshake with
  * the parent's breakpoints re-sent before configurationDone, every event the
- * connection produces forwarded under the child's session id — or released,
- * the request answered `success: false`, on which debugpy unblocks the child
- * itself. A report nobody answers is released by a safety timer, so a child is
- * never parked forever by a silent parent. Every connection opened here is
- * closed here: the adapter lives while any client socket is open.
+ * connection produces forwarded under the child's session id — or released
+ * by the policy's lever: the request answered `success: false`, on which
+ * debugpy unblocks the child itself, or (js-debug, issue #1082, whose report
+ * is acked the moment it is held because its answer decides nothing) a
+ * throwaway connection that attaches to the target and detaches again. A
+ * report nobody answers is released by a safety timer, so a child is never
+ * parked forever by a silent parent. Every connection opened here is closed
+ * here: the adapter lives while any client socket is open.
  */
 import { EventEmitter } from 'events';
 import { randomUUID } from 'node:crypto';
 import path from 'path';
 import type { DebugProtocol } from '@vscode/debugprotocol';
 import { resolveExceptionFilters } from '@debugmcp/shared';
-import type { AdapterPolicy, ChildReport, LanguageSpecificLaunchConfig } from '@debugmcp/shared';
+import type { AdapterPolicy, ChildAdoptionContract, ChildReport, LanguageSpecificLaunchConfig } from '@debugmcp/shared';
 import type { DapConnectionManager } from './dap-proxy-connection-manager.js';
+import { createChildSafePolicy } from './child-safe-policy.js';
+import { releaseByThrowawayAttach } from './throwaway-release.js';
 import type {
   BreakpointSyncResult,
   ChildAdoptArgs,
@@ -98,6 +103,8 @@ export class ChildConnections extends EventEmitter {
   private readonly clients = new Map<string, ChildConnection>();
   private readonly releaseTimeoutMs: number;
   private closing = false;
+  /** The policy the connections opened here run (child-safe for an in-session adopter, issue #1082). */
+  private connectionPolicy?: AdapterPolicy;
 
   constructor(private readonly options: ChildConnectionsOptions) {
     super();
@@ -108,11 +115,14 @@ export class ChildConnections extends EventEmitter {
    * Hold every child reported on this connection and tell the parent process.
    * `connectionSessionId` is the session the connection serves: the root's id
    * for the root connection, the child's id for an adopted child (so a
-   * grandchild's report is stamped with its spawning session).
+   * grandchild's report is stamped with its spawning session). A report the
+   * client relays from another connection (js-debug's program target, whose
+   * forks are reported on its own connection) names that connection as
+   * `client`: the answer goes there.
    */
   attach(client: IDapClient, connectionSessionId: string): void {
-    client.on('child-report', ({ request, report }: { request: DebugProtocol.Request; report: ChildReport }) => {
-      this.hold(client, connectionSessionId, request, report);
+    client.on('child-report', ({ request, report, client: origin }: { request: DebugProtocol.Request; report: ChildReport; client?: IDapClient }) => {
+      this.hold(origin ?? client, connectionSessionId, request, report);
     });
   }
 
@@ -132,9 +142,10 @@ export class ChildConnections extends EventEmitter {
   }
 
   /**
-   * Release a held report: answer the adapter `success: false` so the child
-   * runs undebugged. Returns false when the report is unknown or already
-   * answered.
+   * Release a held report so the child runs undebugged, by the policy's
+   * lever: answer the adapter `success: false` (debugpy), or attach a
+   * throwaway connection and detach again (js-debug; runs on after this
+   * returns). Returns false when the report is unknown or already answered.
    */
   release(reportId: string, reason: string): boolean {
     const held = this.takeHeld(reportId);
@@ -142,7 +153,11 @@ export class ChildConnections extends EventEmitter {
       return false;
     }
     this.options.logger.info(`[ChildConnections] Releasing child ${held.report.targetId} (${held.report.name}): ${reason}`);
-    held.client.respondToReverseRequest?.(held.request, {}, false, reason);
+    if (this.lever() === 'throwaway-attach') {
+      void this.releaseByThrowaway(held, reason);
+    } else {
+      held.client.respondToReverseRequest?.(held.request, {}, false, reason);
+    }
     return true;
   }
 
@@ -185,7 +200,7 @@ export class ChildConnections extends EventEmitter {
     let initializedTimer: NodeJS.Timeout | undefined;
     let onInitialized: (() => void) | undefined;
     try {
-      client = deps.dapClientFactory.create(deps.host, deps.port, deps.policy, { traceLabel: label });
+      client = deps.dapClientFactory.create(deps.host, deps.port, this.policyForConnections(deps), { traceLabel: label });
       let cancelAdoption!: (reason: string) => void;
       const cancelled = new Promise<never>((_, reject) => {
         cancelAdoption = (reason) => reject(new Error(reason));
@@ -207,7 +222,10 @@ export class ChildConnections extends EventEmitter {
       });
       const capabilities = await wait(deps.connectionManager.initializeSession(client, childSessionId, deps.adapterId));
 
-      const attach = deps.connectionManager.sendAttachRequest(client, contract.buildChildAttachArguments(held.report));
+      const attach = deps.connectionManager.sendAttachRequest(
+        client,
+        contract.buildChildAttachArguments(held.report, deps.launchConfig as Readonly<Record<string, unknown>> | undefined)
+      );
       const attachFailure = new Promise<never>((_, reject) => {
         attach.catch(reject);
       });
@@ -227,7 +245,7 @@ export class ChildConnections extends EventEmitter {
       await wait(attach);
 
       connection.cancelAdoption = undefined;
-      held.client.respondToReverseRequest?.(held.request, {}, true, undefined);
+      this.answer(held, true);
       logger.info(`[ChildConnections] Child ${held.report.targetId} adopted as session ${childSessionId}`);
       return { sessionId: childSessionId, capabilities };
     } catch (error) {
@@ -242,7 +260,7 @@ export class ChildConnections extends EventEmitter {
           this.emitEmptyIfSo();
         }
       }
-      held.client.respondToReverseRequest?.(held.request, {}, false, `adoption failed: ${message}`);
+      this.answer(held, false, `adoption failed: ${message}`);
       try {
         client?.shutdown(`child adoption failed: ${message}`);
       } catch {
@@ -308,8 +326,15 @@ export class ChildConnections extends EventEmitter {
   // ----- internals -----
 
   private hold(client: IDapClient, connectionSessionId: string, request: DebugProtocol.Request, report: ChildReport): void {
+    const throwaway = this.lever() === 'throwaway-attach';
     if (this.closing) {
-      client.respondToReverseRequest?.(request, {}, false, 'worker shutdown');
+      if (throwaway) {
+        // The worker is going down with its adapter; nothing can attach to this target any more.
+        this.options.logger.warn(`[ChildConnections] Child ${report.targetId} (${report.name}) reported during worker shutdown stays parked`);
+        client.respondToReverseRequest?.(request, {}, true, undefined);
+      } else {
+        client.respondToReverseRequest?.(request, {}, false, 'worker shutdown');
+      }
       return;
     }
     const reportId = randomUUID();
@@ -318,6 +343,12 @@ export class ChildConnections extends EventEmitter {
     }, this.releaseTimeoutMs);
     timer.unref?.();
     this.held.set(reportId, { request, report, client, connectionSessionId, timer });
+    if (throwaway) {
+      // The answer decides nothing for this adapter (a pending target is
+      // resolved only by a connection attaching with its id), so answer
+      // once, now, and never again for this request.
+      client.respondToReverseRequest?.(request, {}, true, undefined);
+    }
     this.options.logger.info(
       `[ChildConnections] Holding child ${report.targetId} (${report.name}) reported on session ${connectionSessionId} as ${reportId}`
     );
@@ -333,6 +364,55 @@ export class ChildConnections extends EventEmitter {
     this.options.messageSender.send(message);
   }
 
+  private lever(): ChildAdoptionContract['releaseLever'] {
+    return this.options.adoption?.policy.childAdoption?.releaseLever ?? 'reject-request';
+  }
+
+  /** Answer a held request the adapter is still waiting on; a throwaway-lever report was answered when held. */
+  private answer(held: HeldReport, success: boolean, message?: string): void {
+    if (this.lever() === 'throwaway-attach') {
+      return;
+    }
+    held.client.respondToReverseRequest?.(held.request, {}, success, message);
+  }
+
+  /** The policy for a connection opened here: never an in-session adopter (issue #1082). */
+  private policyForConnections(deps: ChildAdoptionDeps): AdapterPolicy {
+    this.connectionPolicy ??= createChildSafePolicy(deps.policy);
+    return this.connectionPolicy;
+  }
+
+  /**
+   * The throwaway release (issues #501, #1082): a fresh connection attaches
+   * to the target so the adapter resumes it, then detaches with the target
+   * kept. A process the released child reports in that window is held like
+   * any other, stamped with the session the released child was reported on.
+   */
+  private async releaseByThrowaway(held: HeldReport, reason: string): Promise<void> {
+    const deps = this.options.adoption;
+    const contract = deps?.policy.childAdoption;
+    const { logger } = this.options;
+    if (!deps || !contract) {
+      logger.warn(`[ChildConnections] Child ${held.report.targetId} (${held.report.name}) cannot be released: this worker opens no connections; it stays parked`);
+      return;
+    }
+    const label = held.report.targetId.slice(0, 8);
+    const client = deps.dapClientFactory.create(deps.host, deps.port, this.policyForConnections(deps), { traceLabel: `release:${label}` });
+    this.attach(client, held.connectionSessionId);
+    const released = await releaseByThrowawayAttach({
+      client,
+      policy: deps.policy,
+      attachArguments: contract.buildChildAttachArguments(held.report, deps.launchConfig as Readonly<Record<string, unknown>> | undefined),
+      label,
+      logger
+    });
+    if (released) {
+      logger.warn(
+        `[ChildConnections] Child ${held.report.targetId} (${held.report.name}) released to run UNDEBUGGED (${reason}) — breakpoints will not bind in that process`
+      );
+    }
+  }
+
   private takeHeld(reportId: string): HeldReport | undefined {
     const held = this.held.get(reportId);
     if (!held) {
diff --git a/src/proxy/child-safe-policy.ts b/src/proxy/child-safe-policy.ts
new file mode 100644
index 000000000..b45183a56
--- /dev/null
+++ b/src/proxy/child-safe-policy.ts
@@ -0,0 +1,68 @@
+/**
+ * The policy every non-root connection of a worker runs (issues #501, #1082).
+ *
+ * A policy that adopts the program itself as a pending target (js-debug,
+ * `supportsReverseStartDebugging`) must never do so again on the connections
+ * it opens for that target, for a fork, or for a throwaway release: a nested
+ * ChildSessionManager would route `pause`/`stackTrace` into a child that
+ * never exists and adopt a grandchild in-session. So those connections run
+ * the same policy with in-session adoption and child routing switched off,
+ * and with every process the adapter reports on them read as a child report
+ * of the session tree (`childAdoption.readChildReport`), handed to the worker
+ * unanswered — a fork is reported on the program's connection, a grandchild
+ * on the fork's (docs/javascript/spike-notes-forks.md).
+ *
+ * A policy without in-session adoption (debugpy) is returned as it is: its
+ * connections already report through the contract.
+ */
+import type { AdapterPolicy, DapClientBehavior } from '@debugmcp/shared';
+
+export function createChildSafePolicy(policy: AdapterPolicy): AdapterPolicy {
+  if (!policy.supportsReverseStartDebugging) {
+    return policy;
+  }
+  const contract = policy.childAdoption;
+
+  return {
+    ...policy,
+    supportsReverseStartDebugging: false,
+    childSessionStrategy: 'none',
+    getDapClientBehavior: (): DapClientBehavior => {
+      const baseBehavior = policy.getDapClientBehavior();
+      const behavior: DapClientBehavior = {
+        ...baseBehavior,
+        childRoutedCommands: new Set<string>(),
+        mirrorBreakpointsToChild: false,
+        pauseAfterChildAttach: false,
+        stackTraceRequiresChild: false,
+        // Child/release connections talk to the real target directly — they
+        // must never self-gate on child availability (issue #513)
+        childRequiredCommands: new Set<string>()
+      };
+
+      const baseHandle = baseBehavior.handleReverseRequest;
+      if (baseHandle || contract) {
+        behavior.handleReverseRequest = async (request, context) => {
+          // A process reported on this connection is a child of the session
+          // the connection serves (issue #1082): held by the worker, never
+          // adopted here and never answered here.
+          const childReport = contract?.readChildReport(request);
+          if (childReport) {
+            return { handled: true, childReport };
+          }
+          if (!baseHandle) {
+            return { handled: false };
+          }
+          const result = await baseHandle(request, context);
+          if (!result.handled) {
+            return result;
+          }
+          // Never adopt in-session on a non-root connection.
+          return { handled: true };
+        };
+      }
+
+      return behavior;
+    }
+  };
+}
diff --git a/src/proxy/child-session-manager.ts b/src/proxy/child-session-manager.ts
index 59dfcfd20..3eb2f14d0 100644
--- a/src/proxy/child-session-manager.ts
+++ b/src/proxy/child-session-manager.ts
@@ -9,10 +9,11 @@
 import { randomBytes } from 'crypto';
 import { EventEmitter } from 'events';
 import { DebugProtocol } from '@vscode/debugprotocol';
-import type { AdapterPolicy, ExceptionBreakMode } from '@debugmcp/shared';
+import type { AdapterPolicy, ChildReport, ExceptionBreakMode } from '@debugmcp/shared';
 import type { DapClientBehavior, ChildSessionConfig, ParentStart } from '@debugmcp/shared';
 import { resolveExceptionFilters } from '@debugmcp/shared';
 import { createLogger } from '../utils/logger.js';
+import { createChildSafePolicy } from './child-safe-policy.js';
 import type { MinimalDapClient } from './minimal-dap.js';
 import { CdpFunctionBreakpointBridge } from './cdp-function-breakpoint-bridge.js';
 import { sendSetBreakpointsStamping, watchConditionSyntaxErrors, matchStoredBreakpoint } from './breakpoint-condition-errors.js';
@@ -38,53 +39,6 @@ function createInstanceId(): string {
   return randomBytes(4).toString('hex');
 }
 
-function createChildSafePolicy(
-  policy: AdapterPolicy,
-  onUnadoptableChild?: (config: ChildSessionConfig) => void
-): AdapterPolicy {
-  if (!policy.supportsReverseStartDebugging) {
-    return policy;
-  }
-
-  return {
-    ...policy,
-    supportsReverseStartDebugging: false,
-    childSessionStrategy: 'none',
-    getDapClientBehavior: (): DapClientBehavior => {
-      const baseBehavior = policy.getDapClientBehavior();
-      const behavior: DapClientBehavior = {
-        ...baseBehavior,
-        childRoutedCommands: new Set<string>(),
-        mirrorBreakpointsToChild: false,
-        pauseAfterChildAttach: false,
-        stackTraceRequiresChild: false,
-        // Child/release connections talk to the real target directly — they
-        // must never self-gate on child availability (issue #513)
-        childRequiredCommands: new Set<string>(),
-      };
-
-      if (baseBehavior.handleReverseRequest) {
-        behavior.handleReverseRequest = async (request, context) => {
-          const result = await baseBehavior.handleReverseRequest!(request, context);
-          if (!result.handled) {
-            return result;
-          }
-          // Do not spawn grandchildren — but do not strand them either
-          // (issue #501): js-debug delivers fork auto-attach startDebugging
-          // requests on the adopted child's connection, so hand the target
-          // to the owning manager, which releases it to run undebugged.
-          if (result.createChildSession && result.childConfig && onUnadoptableChild) {
-            onUnadoptableChild(result.childConfig);
-          }
-          return { handled: true };
-        };
-      }
-
-      return behavior;
-    },
-  };
-}
-
 export interface ChildSessionOptions {
   policy: AdapterPolicy;
   host: string;
@@ -711,7 +665,10 @@ export class ChildSessionManager extends EventEmitter {
       adapterID: this.policy.getDapAdapterConfiguration().type,
       pathFormat: 'path',
       linesStartAt1: true,
-      columnsStartAt1: true
+      columnsStartAt1: true,
+      // The session tree (issue #1082): the processes this target starts are
+      // reported on this connection; ask for the request form here too.
+      ...(this.policy.childAdoption?.advertiseStartDebugging ? { supportsStartDebuggingRequest: true } : {})
     };
     
     logger.info(`[child:${pendingId}] initialize`);
@@ -866,19 +823,13 @@ export class ChildSessionManager extends EventEmitter {
   }
 
   /**
-   * Child-safe policy wired back to this manager: a startDebugging arriving
-   * on a child (or release) connection is handed to createChildSession,
-   * which — with a child already active — releases it (issue #501).
-   * Fire-and-forget: the DAP ack was already sent by the base policy, and a
-   * release must not block the child's message dispatch.
+   * The policy the program target's (and a release's) connection runs: no
+   * in-session adoption, no child routing, and every process the adapter
+   * reports on it read as a child report (issue #1082) that wireChildEvents
+   * relays to the root connection's holder, unanswered.
    */
   private buildChildSafePolicy(): AdapterPolicy {
-    return createChildSafePolicy(this.policy, (config) => {
-      void this.createChildSession(config).catch((err) => {
-        const msg = err instanceof Error ? err.message : String(err);
-        logger.error(`[ChildSessionManager:${this.instanceId}] Forwarded unadoptable child ${config.pendingId} failed: ${msg}`);
-      });
-    });
+    return createChildSafePolicy(this.policy);
   }
 
   /**
@@ -1076,6 +1027,13 @@ export class ChildSessionManager extends EventEmitter {
    * Wire child events to forward to parent
    */
   private wireChildEvents(child: MinimalDapClient): void {
+    // A fork is reported on the program target's connection, i.e. on this
+    // child (issue #1082): relay the held request, with the connection it
+    // must be answered on, for the root client to hand to the worker.
+    child.on('child-report', (held: { request: DebugProtocol.Request; report: ChildReport }) => {
+      this.emit('childReport', { request: held.request, report: held.report, client: child });
+    });
+
     child.on('event', (evt: DebugProtocol.Event) => {
       if (evt.event === 'stopped') {
         this.sawChildStop = true;
diff --git a/src/proxy/minimal-dap.ts b/src/proxy/minimal-dap.ts
index 900f09ab4..8106a0295 100644
--- a/src/proxy/minimal-dap.ts
+++ b/src/proxy/minimal-dap.ts
@@ -16,6 +16,7 @@ import {
   DapClientBehavior,
   DapClientContext,
   type ParentStart,
+  type ChildReport,
   type ChildSessionConfig,
   buildNoDebugTargetError,
   sanitizePayloadForLogging,
@@ -173,6 +174,13 @@ export class MinimalDapClient extends EventEmitter implements IDapClient {
         logger.error('[MinimalDapClient] Child session error:', error);
       });
 
+      // A process reported on the program target's connection is a child of
+      // this (the launch) session (issue #1082): hand it to this connection's
+      // holder, to be answered on the connection it arrived on.
+      this.childSessionManager.on('childReport', (held: { request: DebugProtocol.Request; report: ChildReport; client: IDapClient }) => {
+        this.relayChildReport(held.request, held.report, held.client);
+      });
+
       this.childSessionManager.on('childClosed', () => {
         logger.info(`[MinimalDapClient] childClosed event: Clearing activeChild`);
         this.childSessions.clear();
@@ -331,16 +339,7 @@ export class MinimalDapClient extends EventEmitter implements IDapClient {
           
           if (result.handled) {
             if (result.childReport) {
-              // A child the debuggee started (the session tree, issue #1081):
-              // the request stays unanswered while whoever listens decides to
-              // adopt or release it. With nobody listening it is released at
-              // once — an acked-but-never-attached child stays parked forever
-              // (docs/python/spike-notes-subprocess.md), a rejected one runs.
-              if (this.listenerCount('child-report') > 0) {
-                this.emit('child-report', { request, report: result.childReport });
-              } else {
-                this.sendResponse(request, {}, false, 'no child-session adopter on this connection: child released');
-              }
+              this.relayChildReport(request, result.childReport, this);
               return;
             }
             // Policy handled the request
@@ -400,6 +399,30 @@ export class MinimalDapClient extends EventEmitter implements IDapClient {
     }
   }
 
+  /**
+   * A child the debuggee started (the session tree, issues #1081/#1082):
+   * the request stays unanswered while whoever listens decides to adopt or
+   * release it; `origin` is the connection it arrived on (this one, or the
+   * program target's), which is where the answer must go. With nobody
+   * listening it is released at once — an acked-but-never-attached child
+   * stays parked forever (docs/python/spike-notes-subprocess.md), a rejected
+   * debugpy child runs; a rejected js-debug child parks too, so it is only
+   * acked and said so.
+   */
+  private relayChildReport(request: DebugProtocol.Request, report: ChildReport, origin: IDapClient): void {
+    if (this.listenerCount('child-report') > 0) {
+      this.emit('child-report', { request, report, client: origin });
+      return;
+    }
+    const reason = 'no child-session adopter on this connection: child released';
+    if (this.policy.childAdoption?.releaseLever === 'throwaway-attach') {
+      logger.warn(`[MinimalDapClient] ${reason} — ${report.name} stays parked (no connection will attach to it)`);
+      origin.respondToReverseRequest?.(request, {}, true, undefined);
+      return;
+    }
+    origin.respondToReverseRequest?.(request, {}, false, reason);
+  }
+
   private appendTrace(direction: 'in' | 'out', payload: unknown): void {
     if (!this.traceFile || this.traceTruncated) return;
     try {
diff --git a/src/proxy/throwaway-release.ts b/src/proxy/throwaway-release.ts
new file mode 100644
index 000000000..b6522c029
--- /dev/null
+++ b/src/proxy/throwaway-release.ts
@@ -0,0 +1,118 @@
+/**
+ * The throwaway release (issues #501, #1082): the one lever that lets a
+ * js-debug pending target run undebugged. The debug server unparks a pending
+ * target only when a DAP connection attaches with its `__pendingTargetId` —
+ * rejecting the report parks the child forever (measured,
+ * docs/javascript/spike-notes-forks.md) — so a connection attaches, gives the
+ * resume a moment to land, and detaches with `terminateDebuggee: false`.
+ *
+ * Never throws and never touches anything but the client it is given, which
+ * it shuts down either way: a failed release must leave every other
+ * connection of the worker intact.
+ */
+import type { DebugProtocol } from '@vscode/debugprotocol';
+import type { AdapterPolicy } from '@debugmcp/shared';
+import type { IDapClient, ILogger } from './dap-proxy-interfaces.js';
+
+/** The whole sequence, connect to detach. */
+export const THROWAWAY_RELEASE_TIMEOUT_MS = 20_000;
+const INITIALIZE_TIMEOUT_MS = 5_000;
+const CONFIGURATION_DONE_TIMEOUT_MS = 5_000;
+const ATTACH_TIMEOUT_MS = 15_000;
+/** How long the resume gets to land before the detach (the policy's ready signal cuts it short). */
+const READY_SIGNAL_TIMEOUT_MS = 1_500;
+const DISCONNECT_TIMEOUT_MS = 3_000;
+
+export interface ThrowawayReleaseOptions {
+  /** A fresh client for the adapter's port, not yet connected; shut down by this function. */
+  client: IDapClient;
+  /** For the adapter id of the initialize and the ready signal (`isChildReadyEvent`). */
+  policy: AdapterPolicy;
+  /** The attach that names the pending target. */
+  attachArguments: Record<string, unknown>;
+  /** The target, for the log. */
+  label: string;
+  logger: ILogger;
+  timeoutMs?: number;
+}
+
+/** Attach to the pending target and detach again; true when the target was resumed. */
+export async function releaseByThrowawayAttach(options: ThrowawayReleaseOptions): Promise<boolean> {
+  const { client, policy, attachArguments, label, logger } = options;
+  const timeoutMs = options.timeoutMs ?? THROWAWAY_RELEASE_TIMEOUT_MS;
+  try {
+    await withTimeout((async () => {
+      await client.connect();
+      // js-debug rejects launch/attach before initialize; the pending-target
+      // attach handler additionally awaits configurationDone.
+      await client.sendRequest('initialize', {
+        clientID: `mcp-release-${label}`,
+        adapterID: policy.getDapAdapterConfiguration().type,
+        pathFormat: 'path',
+        linesStartAt1: true,
+        columnsStartAt1: true
+      }, INITIALIZE_TIMEOUT_MS);
+      try {
+        await client.sendRequest('configurationDone', {}, CONFIGURATION_DONE_TIMEOUT_MS);
+      } catch {
+        logger.warn(`[release:${label}] configurationDone failed or not required`);
+      }
+      logger.info(`[release:${label}] attach (throwaway connection)`);
+      await client.sendRequest('attach', attachArguments, ATTACH_TIMEOUT_MS);
+      // The resume runs just after the attach response resolves; wait for
+      // the policy's ready signal so a fast disconnect cannot detach from a
+      // target that is still parked.
+      await waitForReadySignal(client, policy, READY_SIGNAL_TIMEOUT_MS);
+      try {
+        await client.sendRequest('disconnect', { terminateDebuggee: false }, DISCONNECT_TIMEOUT_MS);
+      } catch {
+        // Best effort — detaching is what matters, and shutdown() below
+        // closes the socket either way.
+      }
+    })(), timeoutMs, `release of pending target ${label} timed out`);
+    return true;
+  } catch (error) {
+    logger.error(`[release:${label}] Failed to release the pending target: ${error instanceof Error ? error.message : String(error)}`);
+    return false;
+  } finally {
+    try {
+      client.shutdown('release complete');
+    } catch {
+      // The socket may already be gone.
+    }
+  }
+}
+
+/** Resolves true on the policy's child-ready signal, false on timeout or client death. */
+function waitForReadySignal(client: IDapClient, policy: AdapterPolicy, timeoutMs: number): Promise<boolean> {
+  return new Promise<boolean>((resolve) => {
+    let done = false;
+    const settle = (value: boolean): void => {
+      if (done) return;
+      done = true;
+      client.off('event', onEvent);
+      client.off('close', onDeath);
+      client.off('error', onDeath);
+      clearTimeout(timer);
+      resolve(value);
+    };
+    const onEvent = (evt: DebugProtocol.Event): void => {
+      if (evt && policy.isChildReadyEvent(evt)) {
+        settle(true);
+      }
+    };
+    const onDeath = (): void => settle(false);
+    const timer = setTimeout(() => settle(false), timeoutMs);
+    client.on('event', onEvent);
+    client.on('close', onDeath);
+    client.on('error', onDeath);
+  });
+}
+
+function withTimeout<T>(operation: Promise<T>, timeoutMs: number, message: string): Promise<T> {
+  let timer: NodeJS.Timeout | undefined;
+  const timeout = new Promise<never>((_, reject) => {
+    timer = setTimeout(() => reject(new Error(message)), timeoutMs);
+  });
+  return Promise.race([operation, timeout]).finally(() => clearTimeout(timer));
+}
diff --git a/src/server/handlers/output-tools.ts b/src/server/handlers/output-tools.ts
index e0378cd83..f4b5a2bde 100644
--- a/src/server/handlers/output-tools.ts
+++ b/src/server/handlers/output-tools.ts
@@ -19,6 +19,10 @@ export async function handleGetOutput(ctx: ToolContext, args: { sessionId: strin
     ? session.outputBuffer.read(since, limit)
     : { entries: [], nextSince: since, hasMore: false, dropped: 0 }; // session created but never launched
   const redaction = redactionSummary(read.entries);
+  // A child whose adapter delivers the tree's output on the launch session
+  // only (js-debug, issue #1082): say where to read instead of answering an
+  // empty page as if the process printed nothing.
+  const outputOn = ctx.sessionManager.outputOnFor(args.sessionId);
   return jsonResult({
     success: true,
     sessionId: args.sessionId,
@@ -26,10 +30,16 @@ export async function handleGetOutput(ctx: ToolContext, args: { sessionId: strin
     nextSince: read.nextSince,
     hasMore: read.hasMore,
     dropped: read.dropped,
-    ...(redaction ? { redaction } : {})
+    ...(redaction ? { redaction } : {}),
+    ...(outputOn ? { outputOn, note: outputOnNote(outputOn) } : {})
   });
 }
 
+/** The one sentence a child answers with when its output lives on the launch session (issue #1082). */
+export function outputOnNote(outputOn: string): string {
+  return `This process's output is on its launch session's buffer (session ${outputOn}); this adapter attributes none of it to the child.`;
+}
+
 export const getOutputTool: ToolHandler = async (ctx, args) => {
   return await handleGetOutput(ctx, args as { sessionId: string; since?: number; limit?: number });
 };
diff --git a/src/server/output-resources.ts b/src/server/output-resources.ts
index 4bc5ea660..ab27c64e5 100644
--- a/src/server/output-resources.ts
+++ b/src/server/output-resources.ts
@@ -13,6 +13,7 @@ import { WireMcpError } from '../errors/debug-errors.js';
 import type { SessionManager } from '../session/session-manager.js';
 import { proxyLogPathFor } from '../proxy/session-log-layout.js';
 import { readProxyLogTail } from '../session/launch/proxy-failure-diagnostics.js';
+import { outputOnNote } from './handlers/output-tools.js';
 import {
   outputResourceUri,
   parseOutputResourceUri,
@@ -169,12 +170,17 @@ export function registerResourceHandlers(
         contents: [{ uri, mimeType: 'text/plain', text: text ?? '' }]
       };
     }
+    // A child whose adapter delivers the tree's output on the launch session
+    // only (js-debug, issue #1082) reads as a pointer to that resource.
+    const outputOn = sessionManager.outputOnFor(session.id);
     return {
       contents: [{
         uri,
         mimeType: 'text/plain',
         // Empty until the first launch creates the buffer
-        text: session.outputBuffer?.renderText() ?? ''
+        text: outputOn
+          ? `${outputOnNote(outputOn)}\nRead ${outputResourceUri(outputOn)} instead.\n`
+          : session.outputBuffer?.renderText() ?? ''
       }]
     };
   });
diff --git a/src/session/session-manager-core.ts b/src/session/session-manager-core.ts
index 64d9d6859..49e3266f9 100644
--- a/src/session/session-manager-core.ts
+++ b/src/session/session-manager-core.ts
@@ -621,7 +621,10 @@ export abstract class SessionManagerCore extends EventEmitter {
     const finishClose = this.beginSubtreeClose(sessionId);
     try {
       for (const descendant of this.descendantsDeepestFirst(sessionId)) {
-        if (await this.closeSingleSession(descendant.id, { releaseChild: releaseDescendants })) {
+        // A child whose adapter can only release it (js-debug, issue #1082)
+        // is closed with its target kept, whatever the cascade.
+        const releaseChild = releaseDescendants || (descendant.proxyManager !== undefined && this.childCloseSemantics(descendant) === 'release');
+        if (await this.closeSingleSession(descendant.id, { releaseChild })) {
           closedSessionIds.push(descendant.id);
         }
       }
@@ -635,7 +638,7 @@ export abstract class SessionManagerCore extends EventEmitter {
           this.logger.warn('[SessionManager] Terminating disconnect failed, closing the session anyway:', disconnectError);
         }
       }
-      const closed = await this.closeSingleSession(sessionId);
+      const closed = await this.closeSingleSession(sessionId, { releaseChild: childEnd === 'release' });
       if (closed) {
         closedSessionIds.push(sessionId);
       }
@@ -701,6 +704,30 @@ export abstract class SessionManagerCore extends EventEmitter {
     }
   }
 
+  /**
+   * Where a child session's output is read (issue #1082): the id of its
+   * tree's root when the adapter delivers the whole tree's output on the
+   * launch session's connection and none on the child's (js-debug, the
+   * policy's `childOutput: 'launch-session'` pin); undefined when the
+   * session's own buffer is the place to read (a root, or a debugpy child
+   * with its own lines).
+   */
+  public outputOnFor(sessionId: string): string | undefined {
+    const session = this.sessionStore.get(sessionId);
+    if (!session?.parentSessionId) {
+      return undefined;
+    }
+    try {
+      if (this.sessionStore.selectPolicy(session.language).childAdoption?.childOutput !== 'launch-session') {
+        return undefined;
+      }
+    } catch {
+      return undefined;
+    }
+    const root = this.rootOf(session);
+    return root.id === session.id ? undefined : root.id;
+  }
+
   /**
    * Close one session: its own proxy (a root's worker, a child's connection
    * — ended, or released to run on when `releaseChild` is set), its row, its
diff --git a/tests/core/unit/server/server-inspection-tools.test.ts b/tests/core/unit/server/server-inspection-tools.test.ts
index f2bd2e1c9..b92eaacba 100644
--- a/tests/core/unit/server/server-inspection-tools.test.ts
+++ b/tests/core/unit/server/server-inspection-tools.test.ts
@@ -696,6 +696,35 @@ describe('Server Inspection Tools Tests', () => {
       expect(content.entries).toHaveLength(1);
     });
 
+    it("says where a child's output is read when its adapter delivers it on the launch session only (js-debug, issue #1082)", async () => {
+      mockSessionManager.getSession.mockReturnValue({
+        id: 'child-session',
+        parentSessionId: 'root-session',
+        sessionLifecycle: 'ACTIVE',
+        outputBuffer: makeBuffer([])
+      });
+      mockSessionManager.outputOnFor.mockReturnValue('root-session');
+
+      const content = await callGetOutput({ sessionId: 'child-session' });
+      expect(content.success).toBe(true);
+      expect(content.entries).toEqual([]);
+      expect(content.outputOn).toBe('root-session');
+      expect(content.note).toContain('root-session');
+      expect(mockSessionManager.outputOnFor).toHaveBeenCalledWith('child-session');
+    });
+
+    it('carries no output pointer for a session that reads its own buffer', async () => {
+      mockSessionManager.getSession.mockReturnValue({
+        id: 'test-session',
+        sessionLifecycle: 'ACTIVE',
+        outputBuffer: makeBuffer(['one\n'])
+      });
+
+      const content = await callGetOutput({ sessionId: 'test-session' });
+      expect(content.outputOn).toBeUndefined();
+      expect(content.note).toBeUndefined();
+    });
+
     it('returns success:false for an unknown session', async () => {
       mockSessionManager.getSession.mockReturnValue(undefined);
 
diff --git a/tests/core/unit/server/server-test-helpers.ts b/tests/core/unit/server/server-test-helpers.ts
index 8f434eae0..fbeb1bd57 100644
--- a/tests/core/unit/server/server-test-helpers.ts
+++ b/tests/core/unit/server/server-test-helpers.ts
@@ -106,6 +106,8 @@ export function createMockSessionManager(mockAdapterRegistry: IAdapterRegistry)
     getSession: vi.fn(),
     closeSession: vi.fn(),
     closeSessionReporting: vi.fn(),
+    // A child whose output rides the launch session (js-debug, issue #1082) answers its root's id.
+    outputOnFor: vi.fn().mockReturnValue(undefined),
     closeAllSessions: vi.fn(),
     setBreakpoint: vi.fn(),
     setFunctionBreakpoint: vi.fn(),
diff --git a/tests/core/unit/session/session-manager-child-sessions.test.ts b/tests/core/unit/session/session-manager-child-sessions.test.ts
index e580a0a4b..5c1e82501 100644
--- a/tests/core/unit/session/session-manager-child-sessions.test.ts
+++ b/tests/core/unit/session/session-manager-child-sessions.test.ts
@@ -5,8 +5,8 @@
  */
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
 import { SessionManager, SessionManagerConfig } from '../../../../src/session/session-manager.js';
-import { DebugLanguage, SessionState } from '@debugmcp/shared';
-import { createMockDependencies, createMockEnvironment } from './session-manager-test-utils.js';
+import { DebugLanguage, JsDebugAdapterPolicy, SessionState } from '@debugmcp/shared';
+import { createMockDependencies, createMockEnvironment, overridePolicy } from './session-manager-test-utils.js';
 import type { MockChildProxyView } from '../../../test-utils/mocks/mock-proxy-manager.js';
 
 const report = (reportId: string, pid = 4242) => ({
@@ -904,4 +904,58 @@ describe('SessionManager child sessions (issue #1081)', () => {
     expect(releases()).toEqual([expect.objectContaining({ args: expect.objectContaining({ reportId: 'r1' }) })]);
     expect(dependencies.mockLogger.warn).toHaveBeenCalledWith(expect.stringContaining('view unavailable'));
   });
+
+  describe('a child whose adapter can only release it, with its output on the launch session (js-debug, issue #1082)', () => {
+    async function jsTree(): Promise<{ rootId: string; childId: string; grandchildId: string; childView: MockChildProxyView; grandchildView: MockChildProxyView }> {
+      overridePolicy(sessionManager, { childAdoption: JsDebugAdapterPolicy.childAdoption });
+      const rootId = await startRoot();
+      dependencies.mockProxyManager.simulateEvent('child-reported', report('r1'));
+      await vi.runAllTimersAsync();
+      const childId = childOf(rootId)!.id;
+      const childView = dependencies.mockProxyManager.childViews.get(childId)!;
+      childView.simulateEvent('child-reported', report('r2', 4343));
+      await vi.runAllTimersAsync();
+      const grandchildId = childOf(childId)!.id;
+      const grandchildView = dependencies.mockProxyManager.childViews.get(grandchildId)!;
+      return { rootId, childId, grandchildId, childView, grandchildView };
+    }
+
+    it('closing the child keeps its target: the connection closes with terminateDebuggee false and the answer says released', async () => {
+      const { rootId, childId, grandchildId, childView, grandchildView } = await jsTree();
+
+      const outcome = await sessionManager.closeSessionReporting(childId);
+
+      expect(outcome).toEqual({ closed: true, closedSessionIds: [grandchildId, childId], childrenClosed: 1, released: true });
+      expect(outcome.processEnded).toBeUndefined();
+      expect(childView.stopOptions[0]).toEqual({ terminateDebuggee: false });
+      expect(grandchildView.stopOptions[0]).toEqual({ terminateDebuggee: false });
+      expect(sessionManager.getSession(rootId)).toBeDefined();
+    });
+
+    it('closing the launch root releases such children on its way down', async () => {
+      const { rootId, childView, grandchildView } = await jsTree();
+
+      const outcome = await sessionManager.closeSessionReporting(rootId);
+
+      expect(outcome.closed).toBe(true);
+      expect(outcome.childrenClosed).toBe(2);
+      expect(outcome.released).toBeUndefined();
+      expect(childView.stopOptions[0]).toEqual({ terminateDebuggee: false });
+      expect(grandchildView.stopOptions[0]).toEqual({ terminateDebuggee: false });
+      expect(sessionManager.getAllSessions()).toHaveLength(0);
+    });
+
+    it("outputOnFor names the tree's root for a child whose output rides the launch session, and nothing otherwise", async () => {
+      const { rootId, childId, grandchildId } = await jsTree();
+
+      expect(sessionManager.outputOnFor(childId)).toBe(rootId);
+      expect(sessionManager.outputOnFor(grandchildId)).toBe(rootId);
+      expect(sessionManager.outputOnFor(rootId)).toBeUndefined();
+      expect(sessionManager.outputOnFor('no-such-session')).toBeUndefined();
+
+      // A debugpy child carries its own lines: no pointer.
+      overridePolicy(sessionManager, { childAdoption: { ...JsDebugAdapterPolicy.childAdoption!, childOutput: 'own-connection' } });
+      expect(sessionManager.outputOnFor(childId)).toBeUndefined();
+    });
+  });
 });
diff --git a/tests/proxy/child-connections.test.ts b/tests/proxy/child-connections.test.ts
index 324cc959a..fbda0a631 100644
--- a/tests/proxy/child-connections.test.ts
+++ b/tests/proxy/child-connections.test.ts
@@ -9,7 +9,7 @@ import type { DebugProtocol } from '@vscode/debugprotocol';
 import { ChildConnections, type ChildAdoptionDeps } from '../../src/proxy/child-connections.js';
 import type { IDapClientFactory, StatusMessage } from '../../src/proxy/dap-proxy-interfaces.js';
 import { createMockDapClient } from '../test-utils/mocks/dap-client.js';
-import { PythonAdapterPolicy } from '@debugmcp/shared';
+import { JsDebugAdapterPolicy, PythonAdapterPolicy, type AdapterPolicy } from '@debugmcp/shared';
 
 const configuration = { type: 'python', name: 'Subprocess 37012', subProcessId: 37012, connect: { host: '127.0.0.1', port: 5678 } };
 const report = { targetId: '37012', name: 'Subprocess 37012', configuration };
@@ -549,3 +549,197 @@ describe('ChildConnections: adopting a reported child', () => {
     expect(connections.release(siblingReportId, 'sibling remains available')).toBe(true);
   });
 });
+
+/**
+ * js-debug's shapes (issue #1082): the report is acked the moment it is held
+ * (its answer decides nothing), release is a throwaway attach-then-detach
+ * on a fresh connection, and every connection opened here runs the
+ * child-safe policy.
+ */
+describe('ChildConnections under the throwaway-attach lever (js-debug, issue #1082)', () => {
+  const sent: Array<Record<string, unknown>> = [];
+  const logger = { info: vi.fn(), error: vi.fn(), debug: vi.fn(), warn: vi.fn() };
+  const jsConfiguration = { type: 'pwa-node', name: 'child.js [4242]', __pendingTargetId: 'a1b2c3d4e5f60718293a4b5c' };
+  const jsReport = { targetId: 'a1b2c3d4e5f60718293a4b5c', name: 'child.js [4242]', configuration: jsConfiguration };
+  const jsStartDebugging = (seq: number): DebugProtocol.Request =>
+    ({ seq, type: 'request', command: 'startDebugging', arguments: { request: 'launch', configuration: jsConfiguration } });
+  let root: ReturnType<typeof createMockDapClient>;
+  let childClient: ReturnType<typeof createMockDapClient>;
+  let releaseClient: ReturnType<typeof createMockDapClient>;
+  let resolveAttach: () => void;
+  let rejectAttach: (error: Error) => void;
+  let dapClientFactory: { create: ReturnType<typeof vi.fn> };
+  let connections: ChildConnections;
+
+  const sentOf = (type: string, extra: (m: Record<string, unknown>) => boolean = () => true) =>
+    sent.filter((m) => m.type === type && extra(m));
+  const reported = () => sentOf('status', (m) => m.status === 'child_reported');
+
+  function build(options: { releaseTimeoutMs?: number; launchConfig?: Record<string, unknown> } = {}): void {
+    sent.length = 0;
+    vi.clearAllMocks();
+    root = createMockDapClient();
+    childClient = createMockDapClient();
+    releaseClient = createMockDapClient();
+    dapClientFactory = {
+      create: vi.fn((_host: string, _port: number, _policy: unknown, opts?: { traceLabel?: string }) =>
+        opts?.traceLabel?.startsWith('release:') ? releaseClient : childClient)
+    };
+    const connectionManager = {
+      initializeSession: vi.fn(async () => ({ supportsConfigurationDoneRequest: true })),
+      sendAttachRequest: vi.fn(() => new Promise<void>((resolve, reject) => { resolveAttach = resolve; rejectAttach = reject; })),
+      setExceptionBreakpoints: vi.fn(async () => ({ body: {} })),
+      setBreakpoints: vi.fn(async () => ({ body: { breakpoints: [{ verified: false }] } })),
+      sendConfigurationDone: vi.fn(async () => { resolveAttach(); }),
+      disconnect: vi.fn(async () => {})
+    };
+    connections = new ChildConnections({
+      messageSender: { send: (message: unknown) => { sent.push(message as Record<string, unknown>); } },
+      logger,
+      ...(options.releaseTimeoutMs !== undefined ? { releaseTimeoutMs: options.releaseTimeoutMs } : {}),
+      adoption: {
+        dapClientFactory: dapClientFactory as unknown as IDapClientFactory,
+        connectionManager: connectionManager as unknown as ChildAdoptionDeps['connectionManager'],
+        policy: JsDebugAdapterPolicy,
+        host: '127.0.0.1',
+        port: 9229,
+        adapterId: 'pwa-node',
+        breakOnExceptions: 'none',
+        ...(options.launchConfig ? { launchConfig: options.launchConfig as never } : {})
+      }
+    });
+    connections.attach(root, 'js-root');
+  }
+
+  beforeEach(() => build());
+
+  /** The release client's sequence, driven to its end (the ready signal posted after the attach). */
+  async function throwawayRan(client: ReturnType<typeof createMockDapClient>): Promise<void> {
+    await vi.waitFor(() => expect(client.sendRequest).toHaveBeenCalledWith('attach', expect.anything(), expect.anything()));
+    client.emit('event', { event: 'thread', body: { reason: 'started', threadId: 1 } });
+    await vi.waitFor(() => expect(client.shutdown).toHaveBeenCalledWith('release complete'));
+  }
+
+  it('answers the report success once when it is held, and the adoption never answers it again', async () => {
+    root.emit('child-report', { request: jsStartDebugging(7), report: jsReport });
+    expect(reported()).toHaveLength(1);
+    expect(root.respondToReverseRequest).toHaveBeenCalledTimes(1);
+    expect(root.respondToReverseRequest).toHaveBeenCalledWith(expect.objectContaining({ seq: 7 }), {}, true, undefined);
+
+    const adopting = connections.adopt('child-1', { reportId: reported()[0].reportId as string, breakpoints: [{ file: '/w/child.js', line: 14 }] });
+    await new Promise((resolve) => setImmediate(resolve));
+    childClient.emit('initialized');
+    await adopting;
+
+    expect(root.respondToReverseRequest).toHaveBeenCalledTimes(1);
+    expect(connections.has('child-1')).toBe(true);
+  });
+
+  it('opens the child connection with the child-safe policy and the measured attach body', async () => {
+    root.emit('child-report', { request: jsStartDebugging(7), report: jsReport });
+    const adopting = connections.adopt('child-1', { reportId: reported()[0].reportId as string, breakpoints: [] });
+    await new Promise((resolve) => setImmediate(resolve));
+    childClient.emit('initialized');
+    await adopting;
+
+    const [, , policy, options] = dapClientFactory.create.mock.calls[0];
+    expect(options).toEqual({ traceLabel: 'child:child-1' });
+    expect(policy).not.toBe(JsDebugAdapterPolicy);
+    expect((policy as AdapterPolicy).supportsReverseStartDebugging).toBe(false);
+    expect((policy as AdapterPolicy).childAdoption).toBe(JsDebugAdapterPolicy.childAdoption);
+    const deps = (connections as unknown as { options: { adoption: ChildAdoptionDeps } }).options.adoption;
+    expect(deps.connectionManager.sendAttachRequest).toHaveBeenCalledWith(childClient, {
+      type: 'pwa-node',
+      request: 'attach',
+      __pendingTargetId: 'a1b2c3d4e5f60718293a4b5c',
+      continueOnAttach: true
+    });
+  });
+
+  it("forwards an attach root's extras into the child attach (issue #466)", async () => {
+    build({ launchConfig: { request: 'attach', port: 9229, localRoot: '/l', remoteRoot: '/r' } });
+    root.emit('child-report', { request: jsStartDebugging(7), report: jsReport });
+    const adopting = connections.adopt('child-1', { reportId: reported()[0].reportId as string, breakpoints: [] });
+    await new Promise((resolve) => setImmediate(resolve));
+    childClient.emit('initialized');
+    await adopting;
+
+    const deps = (connections as unknown as { options: { adoption: ChildAdoptionDeps } }).options.adoption;
+    expect(deps.connectionManager.sendAttachRequest).toHaveBeenCalledWith(childClient, expect.objectContaining({ localRoot: '/l', remoteRoot: '/r', __pendingTargetId: 'a1b2c3d4e5f60718293a4b5c' }));
+    expect(deps.connectionManager.sendAttachRequest).toHaveBeenCalledWith(childClient, expect.not.objectContaining({ port: 9229 }));
+  });
+
+  it('release runs the throwaway attach on a fresh child-safe connection and never refuses the request', async () => {
+    root.emit('child-report', { request: jsStartDebugging(7), report: jsReport });
+    const reportId = reported()[0].reportId as string;
+
+    expect(connections.release(reportId, 'over the child cap')).toBe(true);
+    expect(connections.release(reportId, 'again')).toBe(false);
+    await throwawayRan(releaseClient);
+
+    expect(dapClientFactory.create).toHaveBeenCalledWith('127.0.0.1', 9229, expect.objectContaining({ supportsReverseStartDebugging: false }), { traceLabel: 'release:a1b2c3d4' });
+    expect(releaseClient.sendRequest.mock.calls.map(([command]) => command)).toEqual(['initialize', 'configurationDone', 'attach', 'disconnect']);
+    expect(releaseClient.sendRequest).toHaveBeenCalledWith('attach', expect.objectContaining({ __pendingTargetId: 'a1b2c3d4e5f60718293a4b5c', continueOnAttach: true }), 15000);
+    expect(releaseClient.sendRequest).toHaveBeenCalledWith('disconnect', { terminateDebuggee: false }, 3000);
+    expect(root.respondToReverseRequest).toHaveBeenCalledTimes(1);
+    expect(root.respondToReverseRequest).not.toHaveBeenCalledWith(expect.anything(), expect.anything(), false, expect.anything());
+    expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining('released to run UNDEBUGGED'));
+    expect(connections.liveCount()).toBe(0);
+  });
+
+  it('the safety timer releases by throwaway too', async () => {
+    build({ releaseTimeoutMs: 20 });
+    root.emit('child-report', { request: jsStartDebugging(7), report: jsReport });
+
+    await throwawayRan(releaseClient);
+
+    expect(logger.info).toHaveBeenCalledWith(expect.stringContaining('no answer from the server within 20 ms'));
+    expect(root.respondToReverseRequest).toHaveBeenCalledTimes(1);
+  });
+
+  it('a process reported on the throwaway connection in the release window is held on the session the released child was reported on', async () => {
+    root.emit('child-report', { request: jsStartDebugging(7), report: jsReport });
+    connections.release(reported()[0].reportId as string, 'over the child cap');
+    await vi.waitFor(() => expect(releaseClient.sendRequest).toHaveBeenCalledWith('attach', expect.anything(), expect.anything()));
+
+    const grandchild = { targetId: 'ffff0000', name: 'grandchild.js [9]', configuration: { type: 'pwa-node', name: 'grandchild.js [9]', __pendingTargetId: 'ffff0000' } };
+    releaseClient.emit('child-report', { request: jsStartDebugging(9), report: grandchild });
+
+    expect(reported().at(-1)).toMatchObject({ sessionId: 'js-root', targetId: 'ffff0000', name: 'grandchild.js [9]' });
+    expect(releaseClient.respondToReverseRequest).toHaveBeenCalledWith(expect.objectContaining({ seq: 9 }), {}, true, undefined);
+    releaseClient.emit('event', { event: 'thread', body: {} });
+    await vi.waitFor(() => expect(releaseClient.shutdown).toHaveBeenCalled());
+  });
+
+  it("a report relayed from the program target's connection is answered on that connection", () => {
+    const programTarget = createMockDapClient();
+    root.emit('child-report', { request: jsStartDebugging(7), report: jsReport, client: programTarget });
+
+    expect(reported()[0]).toMatchObject({ sessionId: 'js-root', targetId: 'a1b2c3d4e5f60718293a4b5c' });
+    expect(programTarget.respondToReverseRequest).toHaveBeenCalledWith(expect.objectContaining({ seq: 7 }), {}, true, undefined);
+    expect(root.respondToReverseRequest).not.toHaveBeenCalled();
+  });
+
+  it('an adoption that fails does not refuse the request either, and tears its connection down', async () => {
+    root.emit('child-report', { request: jsStartDebugging(7), report: jsReport });
+    const adopting = connections.adopt('child-1', { reportId: reported()[0].reportId as string, breakpoints: [] });
+    await new Promise((resolve) => setImmediate(resolve));
+    rejectAttach(new Error('attach refused'));
+    await expect(adopting).rejects.toThrow('attach refused');
+
+    expect(root.respondToReverseRequest).toHaveBeenCalledTimes(1);
+    expect(root.respondToReverseRequest).not.toHaveBeenCalledWith(expect.anything(), expect.anything(), false, expect.anything());
+    expect(childClient.shutdown).toHaveBeenCalled();
+    expect(connections.has('child-1')).toBe(false);
+  });
+
+  it('a report during worker shutdown is acked and left parked, with a warning', async () => {
+    await connections.closeAll('worker shutdown');
+    root.emit('child-report', { request: jsStartDebugging(7), report: jsReport });
+
+    expect(reported()).toHaveLength(0);
+    expect(root.respondToReverseRequest).toHaveBeenCalledWith(expect.objectContaining({ seq: 7 }), {}, true, undefined);
+    expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining('stays parked'));
+    expect(dapClientFactory.create).not.toHaveBeenCalled();
+  });
+});
diff --git a/tests/proxy/child-session-manager.test.ts b/tests/proxy/child-session-manager.test.ts
index bb7db632a..7005748f3 100644
--- a/tests/proxy/child-session-manager.test.ts
+++ b/tests/proxy/child-session-manager.test.ts
@@ -487,7 +487,7 @@ describe('ChildSessionManager', () => {
         }
       });
 
-      it('uses the same parent intent for a release forwarded from a child connection', async () => {
+      it("a fork's startDebugging on the adopted child's connection is a child report, not a release (issue #1082)", async () => {
         vi.useFakeTimers();
         try {
           const getParentStart = vi.fn(() => start);
@@ -508,44 +508,26 @@ describe('ChildSessionManager', () => {
           getParentStart.mockClear();
 
           // js-debug delivers a fork's startDebugging on the adopted child's
-          // own connection; the child-safe policy hands it back to the
-          // manager (issue #501). Drive that handler exactly as the child's
-          // MinimalDapClient would.
+          // own connection. The child-safe policy reads it as a child report
+          // for the worker to hold (the session tree); the manager neither
+          // acks nor releases it, so its parent intent is never consulted.
           const child = MockMinimalDapClient.instances[0];
           const result = await forwardStartDebugging(child, {
             type: 'pwa-node',
             name: 'fork',
             __pendingTargetId: 'forked-child'
           });
-          expect(result.handled).toBe(true);
-          // The release runs the attach + ready-signal wait + disconnect
+          expect(result).toEqual({
+            handled: true,
+            childReport: { targetId: 'forked-child', name: 'fork', configuration: { type: 'pwa-node', name: 'fork', __pendingTargetId: 'forked-child' } }
+          });
           await vi.advanceTimersByTimeAsync(20000);
 
-          expect(getParentStart).toHaveBeenCalledExactlyOnceWith();
-          // The release uses the same attach extras as direct adoption.
-          const release = findReleaseClient('forked-child');
-          expect(release).toBeDefined();
-          expect(release!.options?.traceLabel).toBe('release:forked-c');
-          const releaseAttach = release!.requests.find((r) => r.command === 'attach');
-          expect(releaseAttach?.args).toEqual(expect.objectContaining({ localRoot: '/forwarded' }));
-
-          // The release RAN TO COMPLETION. Everything above holds just as well
-          // for a release that timed out mid-flight or rolled back, because the
-          // attach is recorded before the ready wait and the disconnect.
-          expect(release!.requests.map((r) => r.command)).toEqual([
-            'initialize',
-            'configurationDone',
-            'attach',
-            'disconnect'
-          ]);
-          expect(
-            (release!.requests.at(-1)!.args as Record<string, unknown>).terminateDebuggee
-          ).toBe(false);
-          expect(release!.shutdownCalls).toEqual(['release complete']);
-          // …and the target stayed marked released rather than rolling back
+          expect(getParentStart).not.toHaveBeenCalled();
+          expect(findReleaseClient('forked-child')).toBeUndefined();
           expect(
             (enriched as unknown as { releasedTargets: Set<string> }).releasedTargets.has('forked-child')
-          ).toBe(true);
+          ).toBe(false);
 
           // The active child was never disturbed
           expect(enriched.getActiveChild()).toBe(child as unknown);
@@ -1819,7 +1801,7 @@ describe('ChildSessionManager', () => {
       }
     }
 
-    it('hands children a policy that cannot spawn grandchildren', async () => {
+    it('hands the program target a policy that never adopts in-session and reads forks as child reports', async () => {
       const baseHandle = vi.fn(async (req: DebugProtocol.Request) =>
         req.command === 'startDebugging' ? { handled: true, wouldSpawn: true } : { handled: false }
       );
@@ -1836,18 +1818,26 @@ describe('ChildSessionManager', () => {
       const childPolicy = MockMinimalDapClient.lastInstance!.policy!;
       expect(childPolicy.supportsReverseStartDebugging).toBe(false);
       expect(childPolicy.childSessionStrategy).toBe('none');
+      expect(childPolicy.childAdoption).toBe(JsDebugAdapterPolicy.childAdoption);
 
       const behavior = childPolicy.getDapClientBehavior();
       expect(behavior.mirrorBreakpointsToChild).toBe(false);
       expect(behavior.pauseAfterChildAttach).toBe(false);
       expect(behavior.childRoutedCommands?.size).toBe(0);
 
-      // A grandchild-spawning reverse request is acknowledged and stopped
+      // A startDebugging that names no pending target is not a report: the
+      // base handler runs, and whatever it would adopt is stopped here.
       const spawnResult = await behavior.handleReverseRequest!(
         { seq: 1, type: 'request', command: 'startDebugging' } as never,
         {} as never
       );
       expect(spawnResult).toEqual({ handled: true });
+      expect(baseHandle).toHaveBeenCalledTimes(1);
+
+      // A fork's report is read through the tree contract, never acked here (issue #1082).
+      const forkResult = await forwardStartDebugging(MockMinimalDapClient.lastInstance!, { __pendingTargetId: 'fork-1', name: 'child.js [7]' });
+      expect(forkResult).toEqual({ handled: true, childReport: { targetId: 'fork-1', name: 'child.js [7]', configuration: { __pendingTargetId: 'fork-1', name: 'child.js [7]' } } });
+      expect(baseHandle).toHaveBeenCalledTimes(1);
 
       // Unhandled reverse requests pass through untouched
       const passthrough = await behavior.handleReverseRequest!(
@@ -1859,28 +1849,33 @@ describe('ChildSessionManager', () => {
       await mgr.shutdown();
     });
 
-    it('releases a fork startDebugging arriving on the child connection (issue #501)', async () => {
+    it("relays a fork reported on the program target's connection as a child report with that connection (issue #1082)", async () => {
       const mgr = new ChildSessionManager({ policy: JsDebugAdapterPolicy, host: 'localhost', port: 9229 });
       await createChild(mgr);
 
-      // js-debug delivers fork auto-attach startDebugging requests on the
-      // ADOPTED CHILD's connection, so the child-safe policy must hand them
-      // back to the manager for release instead of dropping them
+      // js-debug delivers fork startDebugging requests on the ADOPTED
+      // CHILD's connection: the manager hands the held request up, naming
+      // the connection it must be answered on, and never releases it itself.
       const forkParent = MockMinimalDapClient.lastInstance!;
+      const relayed = vi.fn();
+      mgr.on('childReport', relayed);
+      const request = { seq: 7, type: 'request', command: 'startDebugging', arguments: { configuration: { __pendingTargetId: 'fork-1' } } };
+      const report = { targetId: 'fork-1', name: 'child.js [7]', configuration: { __pendingTargetId: 'fork-1' } };
 
-      vi.useFakeTimers();
-      try {
-        const result = await forwardStartDebugging(forkParent, { __pendingTargetId: 'grandchild-1' });
-        expect(result).toEqual({ handled: true });
-        // The forward is fire-and-forget; drive the release flow to completion
-        await vi.advanceTimersByTimeAsync(25000);
-      } finally {
-        vi.useRealTimers();
-      }
+      forkParent.emit('child-report', { request, report });
+
+      expect(relayed).toHaveBeenCalledWith({ request, report, client: forkParent });
+      expect(findReleaseClient('fork-1'), 'the manager no longer releases forks itself').toBeUndefined();
+
+      await mgr.shutdown();
+    });
+
+    it("advertises supportsStartDebuggingRequest on the program target's initialize under the tree contract (issue #1082)", async () => {
+      const mgr = new ChildSessionManager({ policy: JsDebugAdapterPolicy, host: 'localhost', port: 9229 });
+      await createChild(mgr);
 
-      const releaseClient = findReleaseClient('grandchild-1');
-      expect(releaseClient, 'the forwarded fork target must be released via a throwaway client').toBeDefined();
-      expect(releaseClient!.shutdownCalls).toEqual(['release complete']);
+      const initialize = MockMinimalDapClient.lastInstance!.requests.find((r) => r.command === 'initialize');
+      expect(initialize?.args).toMatchObject({ supportsStartDebuggingRequest: true });
 
       await mgr.shutdown();
     });
diff --git a/tests/proxy/dap-proxy-worker-child-sessions.test.ts b/tests/proxy/dap-proxy-worker-child-sessions.test.ts
index 0bb6e448b..80403e62c 100644
--- a/tests/proxy/dap-proxy-worker-child-sessions.test.ts
+++ b/tests/proxy/dap-proxy-worker-child-sessions.test.ts
@@ -26,6 +26,9 @@ import { createMockFileSystem, createMockProcessSpawner } from '../test-utils/mo
 
 type SentMessage = StatusMessage | DapResponseMessage | DapEventMessage | ErrorMessage;
 
+/** A policy that reports no children (the ten adapters without the tree contract), with debugpy's spawn configuration. */
+const noContractPolicy = { ...PythonAdapterPolicy, childAdoption: undefined } as unknown as typeof PythonAdapterPolicy;
+
 const configuration = { type: 'python', name: 'Subprocess 4242', subProcessId: 4242, connect: { host: '127.0.0.1', port: 5678 } };
 const report = { targetId: '4242', name: 'Subprocess 4242', configuration };
 const startDebugging = { seq: 7, type: 'request' as const, command: 'startDebugging', arguments: { request: 'attach', configuration } };
@@ -152,9 +155,26 @@ describe('DapProxyWorker child sessions (issue #1081)', () => {
     expect(response).toMatchObject({ success: true, sessionId: 'py-root', body: { released: true } });
   });
 
-  it('installs no child-report listener for a policy without the tree contract (js-debug stays as it was)', async () => {
+  it('holds the reports of a js-debug root too: every target after the program is a child of the tree (issue #1082)', async () => {
     await connectUnder(JsDebugAdapterPolicy);
 
+    const listened = rootClient.on.mock.calls.map(([event]) => event);
+    expect(listened).toContain('child-report');
+
+    const forkRequest = { seq: 9, type: 'request' as const, command: 'startDebugging', arguments: { request: 'launch', configuration: { type: 'pwa-node', name: 'child.js [7]', __pendingTargetId: 'fork-1' } } };
+    const forkReport = { targetId: 'fork-1', name: 'child.js [7]', configuration: forkRequest.arguments.configuration };
+    rootClient.emit('child-report', { request: forkRequest, report: forkReport });
+
+    const reported = statuses('child_reported');
+    expect(reported).toHaveLength(1);
+    expect(reported[0]).toMatchObject({ sessionId: 'py-root', targetId: 'fork-1', name: 'child.js [7]' });
+    // js-debug's report is answered the moment it is held: the answer decides nothing.
+    expect(rootClient.respondToReverseRequest).toHaveBeenCalledWith(expect.objectContaining({ seq: 9 }), {}, true, undefined);
+  });
+
+  it('installs no child-report listener for a policy without the tree contract', async () => {
+    await connectUnder(noContractPolicy);
+
     const listened = rootClient.on.mock.calls.map(([event]) => event);
     expect(listened).not.toContain('child-report');
   });
@@ -332,7 +352,7 @@ describe('DapProxyWorker child sessions (issue #1081)', () => {
   });
 
   it('refuses child commands when this adapter has no adoption contract', async () => {
-    await connectUnder(JsDebugAdapterPolicy);
+    await connectUnder(noContractPolicy);
     await worker.handleCommand({ cmd: 'dap', sessionId: 'child-1', requestId: 'unsupported-adopt', dapCommand: CHILD_ADOPT_COMMAND });
     expect(responseTo('unsupported-adopt')).toMatchObject({ success: false, sessionId: 'child-1', error: expect.stringContaining('reports no child processes') });
   });
diff --git a/tests/unit/proxy/dap-proxy-connection-manager.test.ts b/tests/unit/proxy/dap-proxy-connection-manager.test.ts
index 0eb196047..a864301a6 100644
--- a/tests/unit/proxy/dap-proxy-connection-manager.test.ts
+++ b/tests/unit/proxy/dap-proxy-connection-manager.test.ts
@@ -395,14 +395,24 @@ describe('DapConnectionManager', () => {
 
     it('leaves supportsStartDebuggingRequest out for a policy without the tree contract', async () => {
       mockDapClient.sendRequest.mockResolvedValue({ success: true });
-      connectionManager.setAdapterPolicy(JsDebugAdapterPolicy);
+      connectionManager.setAdapterPolicy(DefaultAdapterPolicy);
 
-      await connectionManager.initializeSession(mockDapClient, 'js-root', 'pwa-node');
+      await connectionManager.initializeSession(mockDapClient, 'default-root', 'default');
 
       const [, args] = mockDapClient.sendRequest.mock.calls[0];
       expect(args).not.toHaveProperty('supportsStartDebuggingRequest');
     });
 
+    it("asks js-debug's child connections for the request form too (issue #1082)", async () => {
+      mockDapClient.sendRequest.mockResolvedValue({ success: true });
+      connectionManager.setAdapterPolicy(JsDebugAdapterPolicy);
+
+      await connectionManager.initializeSession(mockDapClient, 'js-child', 'pwa-node');
+
+      const [, args] = mockDapClient.sendRequest.mock.calls[0];
+      expect(args).toHaveProperty('supportsStartDebuggingRequest', true);
+    });
+
     it('should handle initialize request failure', async () => {
       const error = new Error('Initialize failed');
       mockDapClient.sendRequest.mockRejectedValue(error);
diff --git a/tests/unit/proxy/minimal-dap.test.ts b/tests/unit/proxy/minimal-dap.test.ts
index bb7d18fbc..bfcec47b1 100644
--- a/tests/unit/proxy/minimal-dap.test.ts
+++ b/tests/unit/proxy/minimal-dap.test.ts
@@ -10,6 +10,7 @@ import type {
 import { DebugProtocol } from '@vscode/debugprotocol';
 import { JsDebugAdapterPolicy } from '@debugmcp/shared';
 import type { ChildSessionConfig, DapClientBehavior, ReverseRequestResult } from '@debugmcp/shared';
+import { createMockDapClient } from '../../test-utils/mocks/dap-client.js';
 
 // Mock the net module
 vi.mock('net');
@@ -1609,10 +1610,35 @@ describe('MinimalDapClient', () => {
 
         await (client as any).handleProtocolMessage(request);
 
-        expect(listener).toHaveBeenCalledWith({ request, report: childReport });
+        // The report names the connection it arrived on (this one): the answer goes there.
+        expect(listener).toHaveBeenCalledWith({ request, report: childReport, client });
         expect(responseSpy).not.toHaveBeenCalled();
       });
 
+      it("relays a report the program target's connection received, naming that connection, unanswered (js-debug, issue #1082)", () => {
+        const manager = createChildSessionManagerStub();
+        const client = new MinimalDapClient('localhost', 9229, JsDebugAdapterPolicy, { childSessionManagerFactory: () => manager });
+        const programTarget = createMockDapClient();
+        const listener = vi.fn();
+        client.on('child-report', listener);
+
+        manager.emit('childReport', { request, report: childReport, client: programTarget });
+
+        expect(listener).toHaveBeenCalledWith({ request, report: childReport, client: programTarget });
+        expect(programTarget.respondToReverseRequest).not.toHaveBeenCalled();
+      });
+
+      it("acks a relayed js-debug report nobody listens for on the connection it came from, and says it stays parked", () => {
+        const manager = createChildSessionManagerStub();
+        const client = new MinimalDapClient('localhost', 9229, JsDebugAdapterPolicy, { childSessionManagerFactory: () => manager });
+        const programTarget = createMockDapClient();
+
+        manager.emit('childReport', { request, report: childReport, client: programTarget });
+
+        // Refusing would park the child just the same (measured); an ack is honest about it.
+        expect(programTarget.respondToReverseRequest).toHaveBeenCalledWith(request, {}, true, undefined);
+      });
+
       it('is released at once when nobody listens, so a child is never parked by default', async () => {
         const { client, responseSpy } = reportingClient();
 
diff --git a/tests/unit/proxy/throwaway-release.test.ts b/tests/unit/proxy/throwaway-release.test.ts
new file mode 100644
index 000000000..f841d0e80
--- /dev/null
+++ b/tests/unit/proxy/throwaway-release.test.ts
@@ -0,0 +1,93 @@
+/**
+ * The throwaway release (issues #501, #1082): the sequence that lets a
+ * js-debug pending target run undebugged — attach with its id, let the
+ * resume land, detach with the target kept — on a client it always shuts
+ * down, never throwing.
+ */
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { JsDebugAdapterPolicy } from '@debugmcp/shared';
+import { releaseByThrowawayAttach } from '../../../src/proxy/throwaway-release.js';
+import { createMockDapClient } from '../../test-utils/mocks/dap-client.js';
+
+const logger = { info: vi.fn(), error: vi.fn(), debug: vi.fn(), warn: vi.fn() };
+const attachArguments = { type: 'pwa-node', request: 'attach', __pendingTargetId: 'fork-1', continueOnAttach: true };
+
+describe('releaseByThrowawayAttach', () => {
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.clearAllMocks();
+  });
+
+  it('connects, initializes, configures, attaches, waits for the ready signal, detaches with the target kept, and shuts down', async () => {
+    const client = createMockDapClient();
+    client.sendRequest.mockImplementation(async (command: string) => {
+      if (command === 'attach') {
+        // js-debug posts `thread` once the target runs: the ready signal.
+        setImmediate(() => client.emit('event', { event: 'thread', body: { reason: 'started', threadId: 1 } }));
+      }
+      return { body: {} };
+    });
+
+    const released = await releaseByThrowawayAttach({ client, policy: JsDebugAdapterPolicy, attachArguments, label: 'fork-1', logger });
+
+    expect(released).toBe(true);
+    expect(client.connect).toHaveBeenCalledTimes(1);
+    expect(client.sendRequest.mock.calls.map(([command]) => command)).toEqual(['initialize', 'configurationDone', 'attach', 'disconnect']);
+    expect(client.sendRequest).toHaveBeenCalledWith('initialize', expect.objectContaining({ adapterID: 'pwa-node', clientID: 'mcp-release-fork-1' }), 5000);
+    expect(client.sendRequest).toHaveBeenCalledWith('attach', attachArguments, 15000);
+    expect(client.sendRequest).toHaveBeenCalledWith('disconnect', { terminateDebuggee: false }, 3000);
+    expect(client.shutdown).toHaveBeenCalledWith('release complete');
+  });
+
+  it('detaches after the ready-signal window when the adapter posts nothing, and tolerates a refused configurationDone', async () => {
+    vi.useFakeTimers();
+    const client = createMockDapClient();
+    client.sendRequest.mockImplementation(async (command: string) => {
+      if (command === 'configurationDone') {
+        throw new Error('not required');
+      }
+      return { body: {} };
+    });
+
+    const releasing = releaseByThrowawayAttach({ client, policy: JsDebugAdapterPolicy, attachArguments, label: 'fork-1', logger });
+    await vi.advanceTimersByTimeAsync(1_600);
+    const released = await releasing;
+
+    expect(released).toBe(true);
+    expect(client.sendRequest).toHaveBeenCalledWith('disconnect', { terminateDebuggee: false }, 3000);
+    expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining('configurationDone failed'));
+  });
+
+  it('reports failure without throwing when the attach is refused, and still shuts the client down', async () => {
+    const client = createMockDapClient();
+    client.sendRequest.mockImplementation(async (command: string) => {
+      if (command === 'attach') {
+        throw new Error('no such pending target');
+      }
+      return { body: {} };
+    });
+
+    const released = await releaseByThrowawayAttach({ client, policy: JsDebugAdapterPolicy, attachArguments, label: 'fork-1', logger });
+
+    expect(released).toBe(false);
+    expect(client.sendRequest).not.toHaveBeenCalledWith('disconnect', expect.anything(), expect.anything());
+    expect(client.shutdown).toHaveBeenCalledWith('release complete');
+    expect(logger.error).toHaveBeenCalledWith(expect.stringContaining('no such pending target'));
+  });
+
+  it('gives up on the whole sequence after its deadline', async () => {
+    vi.useFakeTimers();
+    const client = createMockDapClient();
+    client.sendRequest.mockImplementation((command: string) =>
+      command === 'attach' ? new Promise(() => {}) : Promise.resolve({ body: {} })
+    );
+
+    const releasing = releaseByThrowawayAttach({ client, policy: JsDebugAdapterPolicy, attachArguments, label: 'fork-1', logger, timeoutMs: 2_000 });
+    await vi.advanceTimersByTimeAsync(2_100);
+    const released = await releasing;
+
+    expect(released).toBe(false);
+    expect(logger.error).toHaveBeenCalledWith(expect.stringContaining('timed out'));
+    expect(client.shutdown).toHaveBeenCalledWith('release complete');
+  });
+});
diff --git a/tests/unit/shared/adapter-policy-contract.test.ts b/tests/unit/shared/adapter-policy-contract.test.ts
index 8c38816e3..6704db5c7 100644
--- a/tests/unit/shared/adapter-policy-contract.test.ts
+++ b/tests/unit/shared/adapter-policy-contract.test.ts
@@ -32,10 +32,53 @@ import {
   type StackFrame,
   type Variable
 } from '@debugmcp/shared';
+import { createChildSafePolicy } from '../../../src/proxy/child-safe-policy.js';
 
 /** The abstract break-on-exception modes `resolveExceptionFilters` accepts. */
 const EXCEPTION_MODES: ExceptionBreakMode[] = ['none', 'uncaught', 'all'];
 
+interface ChildReportFixture {
+  /** The adapter's `startDebugging` for a process the debuggee started, as measured. */
+  request: DebugProtocol.Request;
+  targetId: string;
+  name: string;
+}
+
+/**
+ * The child reports the two reporting engines send (issues #1081/#1082), in the shape each
+ * spike measured: debugpy's names the parent's program and the adapter's own port under
+ * `request: 'attach'`; js-debug's is three keys under `request: 'launch'`, whatever the
+ * adoption is (docs/javascript/spike-notes-forks.md).
+ */
+const CHILD_REPORT_FIXTURES: Partial<Record<DebugLanguage, ChildReportFixture>> = {
+  [DebugLanguage.PYTHON]: {
+    request: {
+      seq: 7,
+      type: 'request',
+      command: 'startDebugging',
+      arguments: {
+        request: 'attach',
+        configuration: { type: 'python', name: 'Subprocess 37012', subProcessId: 37012, connect: { host: '127.0.0.1', port: 5678 } }
+      }
+    },
+    targetId: '37012',
+    name: 'Subprocess 37012'
+  },
+  [DebugLanguage.JAVASCRIPT]: {
+    request: {
+      seq: 8,
+      type: 'request',
+      command: 'startDebugging',
+      arguments: {
+        request: 'launch',
+        configuration: { type: 'pwa-node', name: 'child.js [4242]', __pendingTargetId: 'a1b2c3d4e5f60718293a4b5c' }
+      }
+    },
+    targetId: 'a1b2c3d4e5f60718293a4b5c',
+    name: 'child.js [4242]'
+  }
+};
+
 interface GeneratedFileHook {
   /** What links the source to the candidate: a `.map` naming it, or the launch that runs it. */
   linkedBy: GeneratedFileCandidate['linkedBy'];
@@ -214,7 +257,7 @@ const PINNED: Record<DebugLanguage, PinnedCapabilities> = {
     stepsByTokenPosition: undefined,
     childSessionStrategy: 'launchWithPendingTarget',
     requiresCommandQueueing: true,
-    childAdoption: undefined,
+    childAdoption: { releaseLever: 'throwaway-attach', childOutput: 'launch-session', closeChild: 'release' },
     defaultExceptionBreakMode: 'uncaught'
   },
   [DebugLanguage.RUST]: {
@@ -437,37 +480,57 @@ describe.each(LANGUAGES)('AdapterPolicy contract — %s', (language) => {
     expect(policy.childAdoption?.advertiseStartDebugging).toBe(true);
   });
 
-  it('never combines the tree contract with the js-shaped reverse adoption', () => {
+  it('combines the tree contract with in-session reverse adoption only when the program is itself a pending target', () => {
     // MinimalDapClient builds the single-target ChildSessionManager for a policy that
-    // `supportsReverseStartDebugging`; a tree-contract policy must not get one.
-    if (policy.childAdoption !== undefined) {
-      expect(policy.supportsReverseStartDebugging).toBe(false);
+    // `supportsReverseStartDebugging`. A tree-contract policy gets one only when its program
+    // arrives as the first pending target (js-debug, issue #1082); every connection it opens
+    // after the root's runs the child-safe derivative, which never adopts in-session.
+    if (policy.childAdoption !== undefined && policy.supportsReverseStartDebugging) {
+      expect(policy.childSessionStrategy).toBe('launchWithPendingTarget');
+      const childSafe = createChildSafePolicy(policy);
+      expect(childSafe.supportsReverseStartDebugging).toBe(false);
+      expect(childSafe.childSessionStrategy).toBe('none');
+      expect(childSafe.childAdoption).toBe(policy.childAdoption);
     }
   });
 
-  it('returns a child report only through the tree contract', async () => {
-    const report: DebugProtocol.Request = {
-      seq: 7,
-      type: 'request',
-      command: 'startDebugging',
-      arguments: {
-        request: 'attach',
-        configuration: { type: 'python', name: 'Subprocess 37012', subProcessId: 37012, connect: { host: '127.0.0.1', port: 5678 } }
+  it('recognises its own child reports through the tree contract, and no other adapter’s', () => {
+    const contract = policy.childAdoption;
+    if (contract === undefined) {
+      return;
+    }
+    const own = CHILD_REPORT_FIXTURES[language];
+    expect(own, `a reporting policy needs a report fixture for ${language}`).toBeDefined();
+    expect(contract.readChildReport(own!.request)).toMatchObject({ targetId: own!.targetId, name: own!.name });
+    for (const [other, fixture] of Object.entries(CHILD_REPORT_FIXTURES)) {
+      if (other !== language && fixture) {
+        expect(contract.readChildReport(fixture.request), `${language} must not read ${other}'s report`).toBeUndefined();
       }
-    };
+    }
+    expect(contract.readChildReport({ seq: 1, type: 'request', command: 'runInTerminal', arguments: {} })).toBeUndefined();
+    // The attach a child connection sends names the target the adapter named.
+    const report = contract.readChildReport(own!.request)!;
+    expect(JSON.stringify(contract.buildChildAttachArguments(report))).toContain(own!.targetId);
+  });
+
+  it('returns a child report only through the tree contract, unanswered', async () => {
+    const fixture = CHILD_REPORT_FIXTURES[language] ?? CHILD_REPORT_FIXTURES[DebugLanguage.PYTHON]!;
     const context = {
       sendResponse: vi.fn(),
       createChildSession: vi.fn(async () => {}),
       activeChildren: new Map<string, unknown>(),
-      adoptedTargets: new Set<string>()
+      // A program that is itself a pending target has been adopted already (js-debug): what
+      // follows is a child of the tree.
+      adoptedTargets: new Set<string>(policy.supportsReverseStartDebugging ? ['the-program'] : [])
     };
-    const result = await policy.getDapClientBehavior().handleReverseRequest?.(report, context);
+    const result = await policy.getDapClientBehavior().handleReverseRequest?.(fixture.request, context);
     if (policy.childAdoption === undefined) {
       expect(result?.childReport).toBeUndefined();
     } else {
-      expect(result).toMatchObject({ handled: true, childReport: { targetId: '37012', name: 'Subprocess 37012' } });
+      expect(result).toMatchObject({ handled: true, childReport: { targetId: fixture.targetId, name: fixture.name } });
       // The report is held by the worker, never answered by the policy.
       expect(context.sendResponse).not.toHaveBeenCalled();
+      expect(context.createChildSession).not.toHaveBeenCalled();
     }
   });
 
diff --git a/tests/unit/shared/adapter-policy-js.test.ts b/tests/unit/shared/adapter-policy-js.test.ts
index 1e3deda3b..41fb3e9cb 100644
--- a/tests/unit/shared/adapter-policy-js.test.ts
+++ b/tests/unit/shared/adapter-policy-js.test.ts
@@ -862,3 +862,83 @@ describe('JsDebugAdapterPolicy.generatedFileCandidates (issue #938)', () => {
     expect(hook({ sourcePath: at('a.tsx') })).toEqual([gen('a.js')]);
   });
 });
+
+describe('JsDebugAdapterPolicy and the session tree (issue #1082)', () => {
+  const contract = JsDebugAdapterPolicy.childAdoption;
+  const pendingId = 'a1b2c3d4e5f60718293a4b5c';
+  const configuration = { type: 'pwa-node', name: 'child.js [4242]', __pendingTargetId: pendingId };
+  const report = (seq: number, cfg: Record<string, unknown> = configuration) =>
+    ({ seq, type: 'request', command: 'startDebugging', arguments: { request: 'launch', configuration: cfg } }) as never;
+  const context = (adopted: string[] = []) => ({
+    sendResponse: vi.fn(),
+    createChildSession: vi.fn(async () => {}),
+    activeChildren: new Map<string, unknown>(),
+    adoptedTargets: new Set<string>(adopted)
+  });
+
+  it('pins the measured facts: throwaway release, output on the launch session, close releases', () => {
+    expect(contract).toMatchObject({
+      advertiseStartDebugging: true,
+      releaseLever: 'throwaway-attach',
+      childOutput: 'launch-session',
+      closeChild: 'release'
+    });
+  });
+
+  it('reads a report off a startDebugging with a pending target id, and nothing else', () => {
+    expect(contract.readChildReport(report(1))).toEqual({ targetId: pendingId, name: 'child.js [4242]', configuration });
+    // A report with no usable name is labelled by its target.
+    expect(contract.readChildReport(report(2, { type: 'pwa-node', __pendingTargetId: pendingId }))?.name).toBe(`target ${pendingId.slice(0, 8)}`);
+    expect(contract.readChildReport(report(3, { type: 'pwa-node', name: 'x' }))).toBeUndefined();
+    expect(contract.readChildReport({ seq: 4, type: 'request', command: 'runInTerminal', arguments: {} } as never)).toBeUndefined();
+    expect(contract.readChildReport({ seq: 5, type: 'request', command: 'startDebugging' } as never)).toBeUndefined();
+  });
+
+  it('attaches a child with the measured second-connection body, forwarding an attach root’s extras only', () => {
+    const child = contract.readChildReport(report(1))!;
+    expect(contract.buildChildAttachArguments(child)).toEqual({
+      type: 'pwa-node',
+      request: 'attach',
+      __pendingTargetId: pendingId,
+      continueOnAttach: true
+    });
+    // A launch root's keys (program, cwd, …) never ride into the child.
+    expect(contract.buildChildAttachArguments(child, { request: 'launch', program: '/w/parent.js', skipFiles: ['<node_internals>/**'] })).toEqual({
+      type: 'pwa-node',
+      request: 'attach',
+      __pendingTargetId: pendingId,
+      continueOnAttach: true
+    });
+    // An attach root's forwardable extras do (issue #466); its connection keys do not.
+    expect(contract.buildChildAttachArguments(child, { request: 'attach', port: 9229, address: 'localhost', localRoot: '/l', remoteRoot: '/r', sourceMaps: true })).toEqual({
+      localRoot: '/l',
+      remoteRoot: '/r',
+      sourceMaps: true,
+      request: 'attach',
+      type: 'pwa-node',
+      __pendingTargetId: pendingId,
+      continueOnAttach: true
+    });
+  });
+
+  it('adopts the first pending target in-session (the program) and hands every later one up as a child report, unanswered', async () => {
+    const behavior = JsDebugAdapterPolicy.getDapClientBehavior();
+
+    const first = context();
+    const program = await behavior.handleReverseRequest!(report(1, { ...configuration, __pendingTargetId: 'the-program' }), first);
+    expect(program).toMatchObject({ handled: true, createChildSession: true, childConfig: { pendingId: 'the-program' } });
+    expect(program.childReport).toBeUndefined();
+    expect(first.sendResponse).toHaveBeenCalledTimes(1);
+    expect(first.adoptedTargets.has('the-program')).toBe(true);
+
+    const later = await behavior.handleReverseRequest!(report(2), first);
+    expect(later).toEqual({ handled: true, childReport: { targetId: pendingId, name: 'child.js [4242]', configuration } });
+    expect(first.sendResponse).toHaveBeenCalledTimes(1);
+    expect(first.adoptedTargets.has(pendingId)).toBe(false);
+
+    // A re-sent request for the program itself is still acked and not a child.
+    const resent = await behavior.handleReverseRequest!(report(3, { ...configuration, __pendingTargetId: 'the-program' }), first);
+    expect(resent).toEqual({ handled: true });
+    expect(first.sendResponse).toHaveBeenCalledTimes(2);
+  });
+});

From 272dd44a719f8b087bfe1cbb31bbad6ff87afb7b Mon Sep 17 00:00:00 2001
From: JF <john.franklin@gmail.com>
Date: Thu, 5 Nov 2026 19:15:33 -0500
Subject: [PATCH 2/6] test(javascript): forks, a grandchild, cap 0, a parent's
 exit and a logpoint against real js-debug (#1082)

The fixture set under tests/fixtures/javascript/subprocess-tree mirrors the
Python one: parent.js forks the child named by argv, child.js ticks three
times over a breakpoint line, child_grand.js spawns grandchild.js
synchronously, parent_exits.js exits with its fork paused, parent_two.js
and cluster_parent.js wait for the second PR's suites.

javascript-subprocess-tree.test.ts, seven cases on the shipped server over
stdio, each naming `autoAttachChildProcesses: true`:

- the designed flow: a breakpoint in child.js only, the root's wait answers
  the fork's three stops with its sessionId and `children`, the fork's own
  output answers `outputOn: <root>`, the root then ends with exit 0 and the
  whole tree's output;
- the grandchild chain: three rows, the grandchild under the fork, the
  root's and the fork's waits both report it;
- closing a paused fork: `released: true`, the fork runs on to its end;
- restart closes the previous run's fork (`childrenClosed: 1`), closing the
  root takes the fork with it;
- cap 0: the program is still adopted, the fork is released by the throwaway
  attach and completes, `childrenReleased: 1`;
- the measurement M2 owed the design doc: an adopted fork paused on a
  breakpoint ends the moment its parent exits (js-debug owns the tree);
- a logpoint set on the parent prints from the fork into the launch
  session's output.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_015BDrn6AsHQ4rmTXFHzQkn8
---
 .../javascript-subprocess-tree.test.ts        | 331 ++++++++++++++++++
 1 file changed, 331 insertions(+)
 create mode 100644 tests/adapters/javascript/integration/javascript-subprocess-tree.test.ts

diff --git a/tests/adapters/javascript/integration/javascript-subprocess-tree.test.ts b/tests/adapters/javascript/integration/javascript-subprocess-tree.test.ts
new file mode 100644
index 000000000..d236115a5
--- /dev/null
+++ b/tests/adapters/javascript/integration/javascript-subprocess-tree.test.ts
@@ -0,0 +1,331 @@
+/**
+ * The session tree with real js-debug (issue #1082): a Node program's forks
+ * used to be released to run undebugged after the program's own target (#501).
+ * With `autoAttachChildProcesses` on, js-debug reports each fork on the
+ * program's connection and the server adopts it as a child debug session on a
+ * connection of its own — the M1 mechanism (#1081) under js-debug's measured
+ * shapes (docs/javascript/spike-notes-forks.md): the report is answered the
+ * moment it is held, release is a throwaway attach, the tree's output lands
+ * on the launch session only, and a child's close releases it.
+ *
+ * Every case names the key explicitly: the default flips in M2's second PR.
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { startStdioClient, type StdioClientHandle, type ToolAnswer } from '../../../test-utils/helpers/mcp-stdio-client.js';
+
+const root = fileURLToPath(new URL('../../../../', import.meta.url));
+const treeDir = path.join(root, 'tests/fixtures/javascript/subprocess-tree');
+const parentFixture = path.join(treeDir, 'parent.js');
+const childFixture = path.join(treeDir, 'child.js');
+const childGrandFixture = path.join(treeDir, 'child_grand.js');
+const grandchildFixture = path.join(treeDir, 'grandchild.js');
+const parentExitsFixture = path.join(treeDir, 'parent_exits.js');
+/** The `// BREAKPOINT` lines of the fixtures. */
+const PARENT_BREAKPOINT_LINE = 20;
+const CHILD_BREAKPOINT_LINE = 14;
+const CHILD_GRAND_BREAKPOINT_LINE = 18;
+const GRANDCHILD_BREAKPOINT_LINE = 9;
+
+interface Row { id: string; name: string; state: string; language: string; parentSessionId?: string }
+interface ChildSummary { sessionId: string; name: string; state: string; parentSessionId: string }
+interface Stop extends ToolAnswer {
+  sessionId?: string;
+  pending?: boolean;
+  exitCode?: number;
+  location?: { file: string; line: number };
+  lastStop?: { line?: number };
+  children?: ChildSummary[];
+  childrenClosed?: number;
+  childrenReleased?: number;
+}
+interface Closed extends ToolAnswer { childrenClosed?: number; processEnded?: boolean; released?: boolean }
+interface Output extends ToolAnswer { entries: Array<{ output: string }>; outputOn?: string; note?: string }
+interface Stack extends ToolAnswer { stackFrames: Array<{ id: number; file?: string; line?: number }> }
+
+let server: StdioClientHandle;
+const call = <T extends ToolAnswer = ToolAnswer>(name: string, args: Record<string, unknown> = {}): Promise<T> => server.call<T>(name, args);
+const rows = async (): Promise<Row[]> => (await call<ToolAnswer & { sessions: Row[] }>('list_debug_sessions')).sessions;
+const outputOf = (sessionId: string): Promise<Output> => call<Output>('get_output', { sessionId, limit: 1000 });
+const outputText = async (sessionId: string): Promise<string> => (await outputOf(sessionId)).entries.map((e) => e.output).join('');
+const lineOf = (stop: Stop): number | undefined => stop.location?.line ?? stop.lastStop?.line;
+const fileOf = (stop: Stop): string => stop.location?.file ?? '';
+
+async function pollUntil<T>(read: () => Promise<T>, accept: (value: T) => boolean, timeoutMs: number, intervalMs = 250): Promise<T> {
+  const deadline = Date.now() + timeoutMs;
+  let last = await read();
+  while (!accept(last) && Date.now() < deadline) {
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    last = await read();
+  }
+  return last;
+}
+
+async function launch(scriptPath: string, extra: Record<string, unknown> = {}): Promise<Stop> {
+  const started = await call<Stop>('start_debugging', {
+    scriptPath,
+    breakOnExceptions: 'none',
+    dapLaunchArgs: { stopOnEntry: false, autoAttachChildProcesses: true },
+    ...extra
+  });
+  expect(started.success, JSON.stringify(started)).toBe(true);
+  return started;
+}
+
+/** Wait on `sessionId` for a stop that must be a paused child of the tree, and hand back its id. */
+async function waitForChildStop(sessionId: string, file: RegExp, line: number): Promise<Stop & { sessionId: string }> {
+  const stop = await call<Stop>('wait_for_stop', { sessionId, timeout: 30000 });
+  expect(stop.state, JSON.stringify(stop)).toBe('paused');
+  expect(stop.sessionId, JSON.stringify(stop)).toBeDefined();
+  expect(stop.sessionId).not.toBe(sessionId);
+  expect(fileOf(stop), JSON.stringify(stop)).toMatch(file);
+  expect(lineOf(stop)).toBe(line);
+  return stop as Stop & { sessionId: string };
+}
+
+async function startClient(env: Record<string, string> = {}): Promise<void> {
+  server = await startStdioClient({ name: 'js-subprocess-tree', callTimeoutMs: 60_000, env });
+}
+
+beforeEach(async () => {
+  await startClient();
+});
+
+afterEach(async () => {
+  await server?.close();
+}, 20_000);
+
+describe('JavaScript forks as child sessions (the session tree, issue #1082)', () => {
+  /**
+   * The designed flow (docs/architecture/session-tree.md): a breakpoint in
+   * the fork's code only, start the parent, wait on the parent. The wait
+   * answers the fork's stop with the fork's id, again after each continue,
+   * and the parent's own end once the fork has ended.
+   */
+  it("the parent's wait_for_stop reports the fork's stops with its sessionId, its output points at the launch session, then the parent ends", async () => {
+    const rootId = await server.createSession('javascript', 'js-tree-designed-flow');
+    const childBp = await call('set_breakpoint', { file: childFixture, line: CHILD_BREAKPOINT_LINE });
+    expect(childBp.success, JSON.stringify(childBp)).toBe(true);
+    const started = await launch(parentFixture);
+    expect(started.state, JSON.stringify(started)).toBe('running');
+
+    let childId: string | undefined;
+    for (let iteration = 0; iteration < 3; iteration += 1) {
+      const stop = await waitForChildStop(rootId, /child\.js$/, CHILD_BREAKPOINT_LINE);
+      childId ??= stop.sessionId;
+      expect(stop.sessionId).toBe(childId);
+      expect(stop.children, JSON.stringify(stop)).toEqual([
+        { sessionId: childId, name: expect.stringMatching(/child\.js \[\d+\]$/), state: 'paused', parentSessionId: rootId }
+      ]);
+      // The answer's own stop is the fork's: inspect it with that id.
+      const stack = await call<Stack>('get_stack_trace', { sessionId: childId });
+      expect(stack.success, JSON.stringify(stack)).toBe(true);
+      expect(stack.stackFrames[0]?.line).toBe(CHILD_BREAKPOINT_LINE);
+      const tick = await call<ToolAnswer & { result?: string }>('evaluate_expression', { sessionId: childId, expression: 'i', frameId: stack.stackFrames[0].id });
+      expect(tick.success, JSON.stringify(tick)).toBe(true);
+      expect(tick.result).toBe(String(iteration));
+      const resumed = await call('continue_execution', { sessionId: childId });
+      expect(resumed.success, JSON.stringify(resumed)).toBe(true);
+    }
+
+    const listing = await rows();
+    const childRow = listing.find((row) => row.id === childId);
+    expect(childRow, JSON.stringify(listing)).toMatchObject({ language: 'javascript', parentSessionId: rootId });
+
+    // The fork runs to its end; the parent then sees its exit code and ends.
+    const ended = await call<Stop>('wait_for_stop', { sessionId: rootId, timeout: 30000 });
+    expect(ended.state, JSON.stringify(ended)).toBe('stopped');
+    expect(ended.sessionId, JSON.stringify(ended)).toBe(rootId);
+    expect(ended.exitCode, JSON.stringify(ended)).toBe(0);
+    expect(ended.children, JSON.stringify(ended)).toEqual([
+      expect.objectContaining({ sessionId: childId, state: 'stopped', parentSessionId: rootId })
+    ]);
+
+    // The whole tree's output is the launch session's (js-debug delivers it on the root connection only)…
+    const rootOutput = await pollUntil(() => outputText(rootId), (text) => text.includes('parent child exit 0'), 5000);
+    expect(rootOutput).toContain('parent start');
+    expect(rootOutput).toContain('child start');
+    expect(rootOutput).toContain('child done 3');
+    expect(rootOutput).toContain('parent child exit 0');
+    // …and the fork's own answer says so instead of pretending it printed nothing.
+    const childOutput = await outputOf(childId!);
+    expect(childOutput.entries).toEqual([]);
+    expect(childOutput.outputOn).toBe(rootId);
+    expect(childOutput.note).toContain(rootId);
+  }, 120_000);
+
+  it('a grandchild the fork starts hangs under the fork, and the root’s wait reports it too', async () => {
+    const rootId = await server.createSession('javascript', 'js-tree-grandchild');
+    expect((await call('set_breakpoint', { file: childGrandFixture, line: CHILD_GRAND_BREAKPOINT_LINE })).success).toBe(true);
+    expect((await call('set_breakpoint', { file: grandchildFixture, line: GRANDCHILD_BREAKPOINT_LINE })).success).toBe(true);
+    await launch(parentFixture, { args: ['child_grand.js'] });
+
+    const childStop = await waitForChildStop(rootId, /child_grand\.js$/, CHILD_GRAND_BREAKPOINT_LINE);
+    const childId = childStop.sessionId;
+    expect((await call('continue_execution', { sessionId: childId })).success).toBe(true);
+
+    const grandchildStop = await waitForChildStop(rootId, /grandchild\.js$/, GRANDCHILD_BREAKPOINT_LINE);
+    const grandchildId = grandchildStop.sessionId;
+    expect(grandchildId).not.toBe(childId);
+    // Pre-order: the fork, then its grandchild; the grandchild's parent is the fork.
+    expect(grandchildStop.children).toEqual([
+      expect.objectContaining({ sessionId: childId, parentSessionId: rootId }),
+      expect.objectContaining({ sessionId: grandchildId, state: 'paused', parentSessionId: childId })
+    ]);
+    const listing = await rows();
+    expect(listing.find((row) => row.id === grandchildId)).toMatchObject({ parentSessionId: childId, name: expect.stringMatching(/grandchild\.js \[\d+\]$/) });
+
+    // A wait on the fork's own id observes its subtree: the paused grandchild.
+    const viaChild = await call<Stop>('wait_for_stop', { sessionId: childId, timeout: 5000 });
+    expect(viaChild.sessionId).toBe(grandchildId);
+
+    expect((await call('continue_execution', { sessionId: grandchildId })).success).toBe(true);
+    const second = await waitForChildStop(rootId, /grandchild\.js$/, GRANDCHILD_BREAKPOINT_LINE);
+    expect(second.sessionId).toBe(grandchildId);
+    expect((await call('continue_execution', { sessionId: grandchildId })).success).toBe(true);
+
+    const ended = await call<Stop>('wait_for_stop', { sessionId: rootId, timeout: 30000 });
+    expect(ended.state, JSON.stringify(ended)).toBe('stopped');
+    expect(ended.sessionId).toBe(rootId);
+    expect(ended.children).toEqual([
+      expect.objectContaining({ sessionId: childId, state: 'stopped' }),
+      expect.objectContaining({ sessionId: grandchildId, state: 'stopped' })
+    ]);
+    const output = await pollUntil(() => outputText(rootId), (text) => text.includes('parent child exit 0'), 5000);
+    expect(output).toContain('grandchild done 3');
+    expect(output).toContain('child grandchild exit 0');
+  }, 120_000);
+
+  it("closing a paused fork releases it to run on (js-debug cannot end a target it adopted), and says released", async () => {
+    const rootId = await server.createSession('javascript', 'js-tree-close-child');
+    expect((await call('set_breakpoint', { file: childFixture, line: CHILD_BREAKPOINT_LINE })).success).toBe(true);
+    await launch(parentFixture);
+    const { sessionId: childId } = await waitForChildStop(rootId, /child\.js$/, CHILD_BREAKPOINT_LINE);
+
+    const closed = await call<Closed>('close_debug_session', { sessionId: childId });
+    expect(closed.success, JSON.stringify(closed)).toBe(true);
+    expect(closed.released, JSON.stringify(closed)).toBe(true);
+    expect(closed.processEnded).toBeUndefined();
+    expect(closed.childrenClosed).toBeUndefined();
+    expect((await rows()).some((row) => row.id === childId)).toBe(false);
+
+    // The released fork finishes undebugged; the parent sees exit 0 and ends.
+    const ended = await call<Stop>('wait_for_stop', { sessionId: rootId, timeout: 30000 });
+    expect(ended.state, JSON.stringify(ended)).toBe('stopped');
+    expect(ended.sessionId).toBe(rootId);
+    const output = await pollUntil(() => outputText(rootId), (text) => text.includes('parent child exit 0'), 5000);
+    expect(output).toContain('child done 3');
+  }, 120_000);
+
+  it("restarting the parent closes the previous run's fork, and closing the parent takes the fork with it", async () => {
+    const rootId = await server.createSession('javascript', 'js-tree-restart-close');
+    expect((await call('set_breakpoint', { file: parentFixture, line: PARENT_BREAKPOINT_LINE })).success).toBe(true);
+    expect((await call('set_breakpoint', { file: childFixture, line: CHILD_BREAKPOINT_LINE })).success).toBe(true);
+
+    const childOf = async (): Promise<Row | undefined> =>
+      (await pollUntil(rows, (listing) => listing.some((row) => row.parentSessionId === rootId), 15000)).find((row) => row.parentSessionId === rootId);
+    const pausedAtParent = async (answer: Stop): Promise<void> => {
+      let paused = answer;
+      if (answer.state !== 'paused') {
+        paused = await call<Stop>('wait_for_stop', { sessionId: rootId, timeout: 30000 });
+      }
+      expect(paused.state, JSON.stringify(paused)).toBe('paused');
+      expect(fileOf(paused)).toMatch(/parent\.js$/);
+      expect(lineOf(paused)).toBe(PARENT_BREAKPOINT_LINE);
+    };
+
+    await pausedAtParent(await launch(parentFixture));
+    const firstChild = await childOf();
+    expect(firstChild, 'the fork is reported while the parent is paused').toBeDefined();
+    const firstChildStop = await call<Stop>('wait_for_stop', { sessionId: firstChild!.id, timeout: 30000 });
+    expect(firstChildStop.state, JSON.stringify(firstChildStop)).toBe('paused');
+
+    const restarted = await call<Stop>('restart_debugging', { sessionId: rootId });
+    expect(restarted.success, JSON.stringify(restarted)).toBe(true);
+    expect(restarted.childrenClosed, JSON.stringify(restarted)).toBe(1);
+    await pausedAtParent(restarted);
+    expect((await rows()).some((row) => row.id === firstChild!.id)).toBe(false);
+
+    const secondChild = await childOf();
+    expect(secondChild).toBeDefined();
+    expect(secondChild!.id).not.toBe(firstChild!.id);
+    const closed = await call<Closed>('close_debug_session', { sessionId: rootId });
+    expect(closed.success, JSON.stringify(closed)).toBe(true);
+    expect(closed.childrenClosed, JSON.stringify(closed)).toBe(1);
+    expect(closed.processEnded).toBeUndefined();
+    server.sessionId = undefined;
+    expect(await rows()).toEqual([]);
+  }, 120_000);
+
+  it('with the child-session cap at 0 the program is still adopted and its fork is released by a throwaway attach', async () => {
+    await server.close();
+    await startClient({ DEBUG_MCP_MAX_CHILD_SESSIONS: '0' });
+    const rootId = await server.createSession('javascript', 'js-tree-cap-0');
+    expect((await call('set_breakpoint', { file: childFixture, line: CHILD_BREAKPOINT_LINE })).success).toBe(true);
+    const started = await launch(parentFixture);
+
+    // No child session, no stop: the fork runs undebugged to its end and the
+    // parent ends with it — inside the launch hold on a fast box, so the
+    // launch answer itself may be the end.
+    const ended = started.state === 'stopped' ? started : await call<Stop>('wait_for_stop', { sessionId: rootId, timeout: 30000 });
+    expect(ended.state, JSON.stringify(ended)).toBe('stopped');
+    if (ended !== started) {
+      expect(ended.sessionId).toBe(rootId);
+    }
+    // A launch answer carries the exit code under `data`; a wait answer hoists it.
+    expect(ended.exitCode ?? (ended as { data?: { exitCode?: number } }).data?.exitCode, JSON.stringify(ended)).toBe(0);
+    expect(ended.childrenReleased, JSON.stringify(ended)).toBe(1);
+    expect(ended.children).toBeUndefined();
+    expect((await rows()).filter((row) => row.parentSessionId === rootId)).toEqual([]);
+    const output = await pollUntil(() => outputText(rootId), (text) => text.includes('parent child exit 0'), 5000);
+    expect(output).toContain('child done 3');
+  }, 120_000);
+
+  /**
+   * Lifecycle row 2 (docs/architecture/session-tree.md): the spike measured
+   * that a program's exit kills its unreported forks within 300 ms, and left
+   * an adopted one unmeasured. Measured here, 2026-11-05 with js-debug
+   * v1.140.0: the adopted fork, paused on its breakpoint, is ended the
+   * moment its parent exits (its `terminated` arrives at the parent's exit;
+   * no exit code) — the launch owns the tree. The server keeps the child's
+   * row until it is closed, as for any ended session.
+   */
+  it('an adopted fork paused on a breakpoint ends with its parent’s exit (measured), and its row says so', async () => {
+    const rootId = await server.createSession('javascript', 'js-tree-parent-exits');
+    expect((await call('set_breakpoint', { file: childFixture, line: CHILD_BREAKPOINT_LINE })).success).toBe(true);
+    await launch(parentExitsFixture);
+    const { sessionId: childId } = await waitForChildStop(rootId, /child\.js$/, CHILD_BREAKPOINT_LINE);
+    expect((await rows()).find((row) => row.id === childId)?.state).toBe('paused');
+
+    // The parent exits 4 s after the fork, while the fork is still paused.
+    const listing = await pollUntil(rows, (list) => list.find((row) => row.id === rootId)?.state === 'stopped', 20000);
+    expect(listing.find((row) => row.id === rootId)?.state, JSON.stringify(listing)).toBe('stopped');
+    const rootOutput = await pollUntil(() => outputText(rootId), (text) => text.includes('parent exiting'), 5000);
+    expect(rootOutput).toContain('parent exiting');
+
+    const childEnd = await pollUntil(rows, (list) => list.find((row) => row.id === childId)?.state === 'stopped', 10000);
+    const childRow = childEnd.find((row) => row.id === childId);
+    expect(childRow, JSON.stringify(childEnd)).toMatchObject({ state: 'stopped', parentSessionId: rootId });
+    // Killed while paused: it never ran its ticks.
+    expect(await outputText(rootId)).not.toContain('child done');
+    const childEnded = await call<Stop>('wait_for_stop', { sessionId: childId, timeout: 5000 });
+    expect(childEnded.state).toBe('stopped');
+    expect(childEnded.exitCode).toBeUndefined();
+  }, 120_000);
+
+  it("a logpoint set on the parent reaches the fork and prints into the launch session's output", async () => {
+    const rootId = await server.createSession('javascript', 'js-tree-logpoint');
+    const logpoint = await call('set_breakpoint', { file: childFixture, line: CHILD_BREAKPOINT_LINE, logMessage: 'tick {i} total {total}' });
+    expect(logpoint.success, JSON.stringify(logpoint)).toBe(true);
+    await launch(parentFixture);
+
+    const ended = await call<Stop>('wait_for_stop', { sessionId: rootId, timeout: 30000 });
+    expect(ended.state, JSON.stringify(ended)).toBe('stopped');
+    expect(ended.sessionId).toBe(rootId);
+    const output = await pollUntil(() => outputText(rootId), (text) => text.includes('parent child exit 0'), 5000);
+    expect(output).toContain('tick 0 total 0');
+    expect(output).toContain('tick 2 total 1');
+    expect(output).toContain('child done 3');
+  }, 120_000);
+});

From 758cc72a7a687f235aa9550fdc0cf8e4463d25aa Mon Sep 17 00:00:00 2001
From: JF <john.franklin@gmail.com>
Date: Thu, 5 Nov 2026 19:15:34 -0500
Subject: [PATCH 3/6] docs(session-tree): M2's first slice, the measured
 parent-exit row, the JavaScript child-process section (#1082)

The design doc's status names M1 complete (#1087, #1090, #1091) and M2's
two PRs; its lifecycle row 2 and the Exit section state what the suite
measured: a js-debug program's exit ends an adopted, paused child at once.
The JavaScript README's child-process section describes the tree (what a
fork answers, `outputOn`, a child's close as a release, the throwaway
release, logpoints yes and function breakpoints no, the parent's exit
ending the tree); CLAUDE.md's proxy paragraph covers the js-debug routing;
the changelog fragment says what shipped and that the default still flips
in the next step.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_015BDrn6AsHQ4rmTXFHzQkn8
---
 CLAUDE.md                         |  2 +-
 changelog.d/1082.added.md         |  1 +
 docs/architecture/session-tree.md | 34 +++++++++++++++++++------------
 docs/javascript/README.md         | 10 ++++-----
 4 files changed, 28 insertions(+), 19 deletions(-)
 create mode 100644 changelog.d/1082.added.md

diff --git a/CLAUDE.md b/CLAUDE.md
index 7f95e643a..5c0c9be3a 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -261,7 +261,7 @@ The codebase follows a **layered architecture with dependency injection** and **
    - **DapProxyWorker** (`dap-proxy-worker.ts`): Core worker handling debugging operations
    - **Adapter Policies**: Language-specific behavior via policy pattern (`DefaultAdapterPolicy`, `PythonAdapterPolicy`, `JsDebugAdapterPolicy`, `RubyAdapterPolicy`, `RustAdapterPolicy`, `GoAdapterPolicy`, `JavaAdapterPolicy`, `DotnetAdapterPolicy`, `CppAdapterPolicy`, `CobolAdapterPolicy`, `DartAdapterPolicy`, `MockAdapterPolicy`); LLDB-generic pieces shared by rust/cpp/cobol live in `lldb-policy-shared.ts`. Note: Java is fully wired to `JavaAdapterPolicy` in `DapProxyWorker.selectAdapterPolicy()` (not falling through to `DefaultAdapterPolicy`).
    - **ChildSessionManager** (`src/proxy/child-session-manager.ts`): Manages DAP child sessions within a single proxy process. Currently used by the js-debug adapter (`childSessionStrategy: 'launchWithPendingTarget'`), which spawns a child debug session for the actual debuggee while the parent session manages the launch orchestration.
-   - **ChildConnections** (`src/proxy/child-connections.ts`) and **ChildProxyView** (`src/proxy/child-proxy-view.ts`): the session tree (issue #1081). One worker serves the root and every child the adapter reports: a policy with a `childAdoption` contract (Python today) makes the worker advertise `supportsStartDebuggingRequest`, hold each report (`child_reported` status, released after 30 s with no answer) until the parent process answers `childAdopt`/`childRelease`/`childClose` on the `dap` envelope, and run the adopted child's handshake on its own connection to the same adapter (DAP trace label `child:<id>`), every event tagged with the child's session id; the parent-side `ProxyManager` demultiplexes by session id into a `ChildProxyView`, an `IProxyManager` over the same IPC channel whose `stop()` closes only that connection. js-debug's single-target adoption of the program itself stays with `ChildSessionManager` (M2 is #1082)
+   - **ChildConnections** (`src/proxy/child-connections.ts`) and **ChildProxyView** (`src/proxy/child-proxy-view.ts`): the session tree (issue #1081). One worker serves the root and every child the adapter reports: a policy with a `childAdoption` contract (Python and JavaScript) makes the worker advertise `supportsStartDebuggingRequest`, hold each report (`child_reported` status, released after 30 s with no answer) until the parent process answers `childAdopt`/`childRelease`/`childClose` on the `dap` envelope, and run the adopted child's handshake on its own connection to the same adapter (DAP trace label `child:<id>`), every event tagged with the child's session id; the parent-side `ProxyManager` demultiplexes by session id into a `ChildProxyView`, an `IProxyManager` over the same IPC channel whose `stop()` closes only that connection. js-debug (issue #1082): the program's own first target stays `ChildSessionManager`'s in-session adoption (the #704 launch-ready signal); every later report — a fork on the program target's connection, a grandchild on the fork's — is relayed as a child report (`childReport` → `child-report`), and every non-root connection runs `createChildSafePolicy` (`src/proxy/child-safe-policy.ts`), so no connection but the root builds a manager. The contract's `releaseLever` decides a release: debugpy's report is refused, js-debug's is acked when held (its answer decides nothing) and released by a throwaway attach-then-detach (`src/proxy/throwaway-release.ts`, #501's lever) — refusing it would park the child forever; `childOutput: 'launch-session'` makes a js child's `get_output`/resource answer `outputOn: <root id>` (`SessionManagerCore.outputOnFor`); `closeChild: 'release'` closes a js child's connection with `terminateDebuggee: false` and answers `released: true`
    - Implements full Debug Adapter Protocol (DAP) communication
 
 ### Key Patterns
diff --git a/changelog.d/1082.added.md b/changelog.d/1082.added.md
new file mode 100644
index 000000000..8983606e4
--- /dev/null
+++ b/changelog.d/1082.added.md
@@ -0,0 +1 @@
+**JavaScript forks become child debug sessions** — a Node launch with `dapLaunchArgs.autoAttachChildProcesses: true` used to adopt the program itself and release every `fork()`, `spawn(process.execPath, …)` or `cluster` worker to run undebugged (#501); js-debug's report of each is now adopted the way debugpy's is (#1081): every process after the program's own becomes a debug session of its own, listed by `list_debug_sessions` with `parentSessionId`, stopping on the parent's breakpoints (re-sent before it runs), reported by the parent's tree-aware `wait_for_stop` with its `sessionId`, with its own `wait_for_stop` and `close_debug_session`; a grandchild hangs under the fork that started it. What js-debug's measured shapes change: the whole tree's output stays on the launch session's buffer (a child's `get_output` and resource answer `outputOn: <launch session id>` instead of an empty page), `close_debug_session` on a child releases it to run on (`released: true` — js-debug cannot end a target it adopted), and a child the server does not adopt (the cap, `DEBUG_MCP_MAX_CHILD_SESSIONS`) is released by a throwaway attach rather than a refusal, which would park it forever. The key still defaults to `false`; the default flips in the next step of #1082 (#1005, #1082).
diff --git a/docs/architecture/session-tree.md b/docs/architecture/session-tree.md
index ad8a6b155..eafd700d9 100644
--- a/docs/architecture/session-tree.md
+++ b/docs/architecture/session-tree.md
@@ -10,12 +10,18 @@ in what order). It is built from the measured facts in
 below cites one of those or a source named in the survey.
 
 Status: decisions taken 2026-11-03 (listed with their owners at the end); merged in
-[#1083](https://github.com/debugmcp/mcp-debugger/pull/1083). Implementation under
-[#1081](https://github.com/debugmcp/mcp-debugger/issues/1081): M1 PR 1 (adoption behind an
-explicit `subProcess: true`) merged in [#1087](https://github.com/debugmcp/mcp-debugger/pull/1087);
-PR 2 (the tree-aware wait and the cascade answers) in [#1090](https://github.com/debugmcp/mcp-debugger/pull/1090);
-the third PR (on by default, the attach measurement, the lifecycle suites) completes M1. M2 is
-[#1082](https://github.com/debugmcp/mcp-debugger/issues/1082).
+[#1083](https://github.com/debugmcp/mcp-debugger/pull/1083). M1
+([#1081](https://github.com/debugmcp/mcp-debugger/issues/1081), Python) is complete: PR 1
+(adoption behind an explicit `subProcess: true`) merged in
+[#1087](https://github.com/debugmcp/mcp-debugger/pull/1087), PR 2 (the tree-aware wait and the
+cascade answers) in [#1090](https://github.com/debugmcp/mcp-debugger/pull/1090), PR 3 (on by
+default, the attach measurement, the lifecycle suites) in
+[#1091](https://github.com/debugmcp/mcp-debugger/pull/1091). M2
+([#1082](https://github.com/debugmcp/mcp-debugger/issues/1082), js-debug) ships in two PRs: the
+first lands the mechanism behind an explicit `autoAttachChildProcesses: true` (every report after
+the program's own is a child session, the throwaway release, `outputOn`, a child's close as a
+release, the fork/grandchild suite and the parent-exit measurement below); the second flips the
+launch and attach defaults and adds the attach, cluster and cascade suites.
 Scope: debuggee children reported by the adapter (debugpy subprocesses, js-debug forks and, later,
 browser targets). The tree is additive to the shipped tool surface: no new tool, no changed
 parameter, new fields only.
@@ -172,10 +178,11 @@ Two measured effects the answers name:
   child ends, because the child inherited the parent's stdout pipe (Python spike, cascade row 2;
   the [#993](https://github.com/debugmcp/mcp-debugger/issues/993) mechanism). While that is the
   case the parent row says `running` and its `wait_for_stop` reports the child.
-- A js-debug program's exit kills its unreported children within 300 ms (JavaScript spike, cascade
-  row 2). That run did not adopt the fork: whether an already adopted child survives its parent's
-  exit is unmeasured and belongs in M2's lifecycle fixture. The server retains the child session
-  until its own terminal event, without promising that the adapter keeps its process alive.
+- A js-debug program's exit ends every process under it: its unreported children within 300 ms
+  (JavaScript spike, cascade row 2), and an adopted child too, even one paused on a breakpoint —
+  its `terminated` arrives at the parent's exit, with no exit code (measured 2026-11-05 in M2's
+  `javascript-subprocess-tree.test.ts`, js-debug v1.140.0). The launch owns the tree. The child's
+  row goes `stopped` and stays listed until closed; the root ends normally with its own exit code.
 
 ### Closing
 
@@ -409,7 +416,7 @@ One row per measured fact; the "answer" column is what this design adds on top o
 | event | debugpy | js-debug | answer |
 |---|---|---|---|
 | child exits while the parent is paused | child `terminated`; the parent, once continued, sees the exit and ends normally (row 1) | same (row 1) | the child row goes `stopped`; the parent's wait still reports the paused parent (rule 1), with the ended child in `children`; after the parent resumes, the child's end alone does not complete that wait (rule 4) |
-| parent exits with a child live | the parent's `exited` is held until the child ends (inherited stdout pipe, #993); the child stays debuggable (row 2) | the program's exit kills unreported children within 300 ms (row 2); an already adopted child's survival is unmeasured, to be checked in M2 | Python: the parent row stays `running` and its wait reports the child; the child row carries `parentSessionId` of a parent that is gone when it finally ends; every adopted child stays listed and follows its own terminal events |
+| parent exits with a child live | the parent's `exited` is held until the child ends (inherited stdout pipe, #993); the child stays debuggable (row 2) | the program's exit kills unreported children within 300 ms (row 2) and ends an adopted, paused child at the same moment — its `terminated` arrives with the parent's exit, no exit code (measured in M2) | Python: the parent row stays `running` and its wait reports the child; the child row carries `parentSessionId` of a parent that is gone when it finally ends. js-debug: the child row goes `stopped` with no exit code and the root ends with its own; every adopted child stays listed and follows its own terminal events |
 | explicit `close_debug_session` on a child | `disconnect(terminateDebuggee: true)`: the child ends, exit 0 reported to the parent (row 4) | `disconnect` with either flag leaves the child running (row 3) | its descendants closed deepest-first, then the child; `processEnded: true` / `released: true`; ancestors, siblings and the shared worker stay open |
 | `close_debug_session` on a launch root | `disconnect(terminateDebuggee: true)` on the root ends the tree (row 6) | only the root's `disconnect` ends the tree, and it never answers (row 6); `terminate` or `disconnect` on a program or child session leave the processes alive (rows 4–5) | children closed deepest-first, then the root; the worker's timeout-then-tree-kill stays the backstop |
 | close or idle expiry of an attach root | `disconnect(terminateDebuggee: false)` releases each child (row 3) | each child keeps running (row 3) | detach descendants deepest-first, then the root; preserve external targets and remove the tree's rows; `released: true`; no target-killing escalation |
@@ -488,8 +495,9 @@ the only one; `autoAttachChildProcesses` defaults on for launch and attach with
 (the `attach_to_process` schema text changes with it); the attach smoke that
 today expects release ([`tests/e2e/mcp-server-smoke-javascript-attach.test.ts`](../../tests/e2e/mcp-server-smoke-javascript-attach.test.ts))
 expects adoption. Reuse M1's subtree-close, idle, attach-target preservation and cleanup-isolation
-cases; verify that cap `0` still adopts the program's own target but releases forks, and measure
-parent exit with an already adopted, paused child. Unblocks #985 M2 (jest and vitest workers as
+cases; verify that cap `0` still adopts the program's own target but releases forks (the first PR's
+suite does), and measure parent exit with an already adopted, paused child (measured in the first
+PR: the child ends with the parent, lifecycle row 2). Unblocks #985 M2 (jest and vitest workers as
 sessions).
 
 **M3 — browser targets.** After the [#989](https://github.com/debugmcp/mcp-debugger/issues/989)
diff --git a/docs/javascript/README.md b/docs/javascript/README.md
index 6a7b21cbc..fa273dbac 100644
--- a/docs/javascript/README.md
+++ b/docs/javascript/README.md
@@ -206,16 +206,16 @@ to inspect these decisions inside a running mcp-debugger server.
 
 ### Child Process Debugging
 
-> One child is adopted today and every further fork is released to run undebugged ([#501](https://github.com/debugmcp/mcp-debugger/issues/501)); the [session tree](../architecture/session-tree.md) design makes each fork a session of its own, from the facts measured in [spike-notes-forks.md](spike-notes-forks.md).
+With `autoAttachChildProcesses: true` every Node process the program starts — a `fork()`, a `spawn(process.execPath, …)`, a `cluster` worker, a grandchild — becomes a child debug session of its own (the [session tree](../architecture/session-tree.md), issue [#1082](https://github.com/debugmcp/mcp-debugger/issues/1082), from the facts measured in [spike-notes-forks.md](spike-notes-forks.md)): listed by `list_debug_sessions` with `parentSessionId`, stopping on the breakpoints set on the parent before launch (re-sent to each child before it runs), reported by the parent's `wait_for_stop` with its `sessionId`. Three things js-debug does differently from debugpy, all answered rather than hidden: the whole tree's output arrives on the launch session's buffer and none of it on a child's — a child's `get_output` answers `outputOn: <launch session id>`; `close_debug_session` on a child releases it to run on (`released: true`) because js-debug cannot end a target it adopted; and a child the server does not adopt (beyond `DEBUG_MCP_MAX_CHILD_SESSIONS`, default 32, `0` off) is released by a throwaway attach-then-detach ([#501](https://github.com/debugmcp/mcp-debugger/issues/501)'s lever), since refusing js-debug's report would park it forever. Function breakpoints do not carry into a child (they are armed over CDP on the program's own target); logpoints do, printing into the launch session's output. The program's exit ends every process under it, a child paused on a breakpoint included (measured): the launch owns the tree, so keep the parent alive while you inspect a child.
 
-The adapter can attach to child processes, but `autoAttachChildProcesses` defaults to `false`. To enable automatic child process attachment, pass it explicitly in `dapLaunchArgs`:
+The key still defaults to `false` (the default flips in M2's second PR); pass it explicitly in `dapLaunchArgs`:
 
 ```javascript
 // parent.js
-const { spawn } = require('child_process');
+const { fork } = require('child_process');
 
-const child = spawn('node', ['child.js']);
-// Debugger will only attach to child.js if autoAttachChildProcesses is set to true
+const child = fork('child.js');
+// child.js becomes a child debug session when autoAttachChildProcesses is true
 ```
 
 ### Conditional Breakpoints

From aa9305e6c5808c0561515017bfc1a4c83c57126c Mon Sep 17 00:00:00 2001
From: JF <john.franklin@gmail.com>
Date: Thu, 5 Nov 2026 19:17:35 -0500
Subject: [PATCH 4/6] =?UTF-8?q?test(javascript):=20track=20the=20subproces?=
 =?UTF-8?q?s-tree=20fixtures=20=E2=80=94=20tests/**/*.js=20is=20ignored=20?=
 =?UTF-8?q?(#1082)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The fixtures are hand-written ESM debuggees, not TypeScript output; without
the negation the ignore rule for compiled tests makes `git add` skip them
silently, the way PR #252 once lost one (the debug-scripts negation above
it is the precedent). The suite committed before this would have run on CI
against files that were never pushed.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_015BDrn6AsHQ4rmTXFHzQkn8
---
 .gitignore                                    |  1 +
 .../javascript/subprocess-tree/child.js       | 22 +++++++++++++
 .../javascript/subprocess-tree/child_grand.js | 23 +++++++++++++
 .../subprocess-tree/cluster_parent.js         | 33 +++++++++++++++++++
 .../javascript/subprocess-tree/grandchild.js  | 17 ++++++++++
 .../javascript/subprocess-tree/parent.js      | 24 ++++++++++++++
 .../subprocess-tree/parent_exits.js           | 24 ++++++++++++++
 .../javascript/subprocess-tree/parent_two.js  | 25 ++++++++++++++
 8 files changed, 169 insertions(+)
 create mode 100644 tests/fixtures/javascript/subprocess-tree/child.js
 create mode 100644 tests/fixtures/javascript/subprocess-tree/child_grand.js
 create mode 100644 tests/fixtures/javascript/subprocess-tree/cluster_parent.js
 create mode 100644 tests/fixtures/javascript/subprocess-tree/grandchild.js
 create mode 100644 tests/fixtures/javascript/subprocess-tree/parent.js
 create mode 100644 tests/fixtures/javascript/subprocess-tree/parent_exits.js
 create mode 100644 tests/fixtures/javascript/subprocess-tree/parent_two.js

diff --git a/.gitignore b/.gitignore
index 1e15b8382..3bee4d9fc 100644
--- a/.gitignore
+++ b/.gitignore
@@ -23,6 +23,7 @@ tests/**/*.js.map
 # Exception: hand-written JS debuggee fixtures (not TS output) — without this
 # negation, `git add` silently skips new fixtures (how PR #252 lost one)
 !tests/fixtures/debug-scripts/*.js
+!tests/fixtures/javascript/subprocess-tree/*.js
 
 # Package source compilation artifacts
 packages/*/src/**/*.js
diff --git a/tests/fixtures/javascript/subprocess-tree/child.js b/tests/fixtures/javascript/subprocess-tree/child.js
new file mode 100644
index 000000000..68691ede0
--- /dev/null
+++ b/tests/fixtures/javascript/subprocess-tree/child.js
@@ -0,0 +1,22 @@
+/**
+ * The child the subprocess-tree parent forks (issue #1082).
+ *
+ * Three ticks of a timer with a breakpoint on the tick's first statement: a
+ * child session adopted with the parent's breakpoints stops here three
+ * times, and the total it prints at the end is the proof it ran to
+ * completion. A timer rather than a loop, so that an adoption that resumes
+ * the park a few milliseconds late still meets the breakpoint.
+ */
+console.log('child start');
+let total = 0;
+let i = 0;
+const timer = setInterval(() => {
+  total += i; // BREAKPOINT
+  console.log(`child step ${i}`);
+  i += 1;
+  if (i === 3) {
+    clearInterval(timer);
+    console.log(`child done ${total}`);
+    process.exit(0);
+  }
+}, 200);
diff --git a/tests/fixtures/javascript/subprocess-tree/child_grand.js b/tests/fixtures/javascript/subprocess-tree/child_grand.js
new file mode 100644
index 000000000..2cea529a6
--- /dev/null
+++ b/tests/fixtures/javascript/subprocess-tree/child_grand.js
@@ -0,0 +1,23 @@
+/**
+ * A child that starts a grandchild (issue #1082).
+ *
+ * The grandchild chain of the session tree's suites: parent.js started with
+ * this script's name as its argument forks it as the child; it ticks once on
+ * its own breakpoint, then runs grandchild.js synchronously the way the spike
+ * did (`spawnSync(process.execPath, …)`), and exits with its status. js-debug
+ * reports the grandchild on this process's connection, so its session hangs
+ * under this one.
+ */
+import { spawnSync } from 'node:child_process';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here = dirname(fileURLToPath(import.meta.url));
+console.log('child start');
+setTimeout(() => {
+  const marker = 1; // BREAKPOINT
+  console.log(`child step ${marker}`);
+  const result = spawnSync(process.execPath, [join(here, 'grandchild.js')], { stdio: 'inherit' });
+  console.log(`child grandchild exit ${result.status}`);
+  process.exit(result.status ?? 1);
+}, 200);
diff --git a/tests/fixtures/javascript/subprocess-tree/cluster_parent.js b/tests/fixtures/javascript/subprocess-tree/cluster_parent.js
new file mode 100644
index 000000000..8f9ed0f86
--- /dev/null
+++ b/tests/fixtures/javascript/subprocess-tree/cluster_parent.js
@@ -0,0 +1,33 @@
+/**
+ * A cluster primary with four workers (issue #1082): each worker is a
+ * `cluster.fork()` js-debug reports on the primary's connection, so every
+ * worker becomes a child session of the primary's; each ticks once on its
+ * breakpoint and exits 0, and the primary exits once all four have.
+ */
+import cluster from 'node:cluster';
+
+const WORKERS = 4;
+
+if (cluster.isPrimary) {
+  console.log('primary start');
+  let exited = 0;
+  cluster.on('exit', (worker, code) => {
+    exited += 1;
+    console.log(`primary worker ${worker.id} exit ${code}`);
+    if (exited === WORKERS) {
+      console.log('primary done');
+      process.exit(0);
+    }
+  });
+  for (let i = 0; i < WORKERS; i += 1) {
+    cluster.fork();
+  }
+} else {
+  const id = cluster.worker.id;
+  console.log(`worker ${id} start`);
+  setTimeout(() => {
+    const marker = id; // BREAKPOINT
+    console.log(`worker ${marker} done`);
+    process.exit(0);
+  }, 200);
+}
diff --git a/tests/fixtures/javascript/subprocess-tree/grandchild.js b/tests/fixtures/javascript/subprocess-tree/grandchild.js
new file mode 100644
index 000000000..edc0bc512
--- /dev/null
+++ b/tests/fixtures/javascript/subprocess-tree/grandchild.js
@@ -0,0 +1,17 @@
+/**
+ * The grandchild child_grand.js starts (issue #1082): two ticks over one
+ * statement with a breakpoint, then exit 0.
+ */
+console.log('grandchild start');
+let total = 0;
+let i = 0;
+const timer = setInterval(() => {
+  total += i + 1; // BREAKPOINT
+  console.log(`grandchild step ${i}`);
+  i += 1;
+  if (i === 2) {
+    clearInterval(timer);
+    console.log(`grandchild done ${total}`);
+    process.exit(0);
+  }
+}, 200);
diff --git a/tests/fixtures/javascript/subprocess-tree/parent.js b/tests/fixtures/javascript/subprocess-tree/parent.js
new file mode 100644
index 000000000..fe3a068a5
--- /dev/null
+++ b/tests/fixtures/javascript/subprocess-tree/parent.js
@@ -0,0 +1,24 @@
+/**
+ * Debuggee that forks a Node child js-debug can report (issue #1082).
+ *
+ * The session tree's M2 fixture. With `autoAttachChildProcesses` on, js-debug
+ * parks the child this program forks and reports it on this program's own
+ * connection; the server adopts the report as a child debug session
+ * (`parentSessionId` = this session's id) that stops on the breakpoints set
+ * on this session before launch. The parent pauses on its own breakpoint
+ * while that happens, then waits for the child's exit code and exits with
+ * it, so the whole tree's end is one number.
+ */
+import { fork } from 'node:child_process';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here = dirname(fileURLToPath(import.meta.url));
+console.log('parent start');
+const childScript = join(here, process.argv[2] ?? 'child.js'); // argv names another child (child_grand.js)
+const child = fork(childScript, [], { stdio: 'inherit' });
+const marker = child.pid; // BREAKPOINT: the parent pauses here while the child is reported and adopted
+child.on('exit', (code) => {
+  console.log(`parent child exit ${code} (${marker})`);
+  process.exit(code ?? 1);
+});
diff --git a/tests/fixtures/javascript/subprocess-tree/parent_exits.js b/tests/fixtures/javascript/subprocess-tree/parent_exits.js
new file mode 100644
index 000000000..58e780435
--- /dev/null
+++ b/tests/fixtures/javascript/subprocess-tree/parent_exits.js
@@ -0,0 +1,24 @@
+/**
+ * A parent that exits with its child still running (issue #1082).
+ *
+ * The session tree's lifecycle row 2 for js-debug: the spike measured that
+ * the program's exit kills its UNREPORTED children within 300 ms; what the
+ * suite measures with this fixture is an already adopted child, paused on a
+ * breakpoint when this parent exits (measured 2026-11-05: js-debug ends it
+ * at the parent's exit — the launch owns the tree). The child is unref'd and
+ * inherits stdio, the spike's shape; the parent waits long enough for the
+ * child's first tick to stop and be observed before it exits.
+ */
+import { fork } from 'node:child_process';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here = dirname(fileURLToPath(import.meta.url));
+console.log('parent start');
+const child = fork(join(here, 'child.js'), [], { stdio: 'inherit' });
+child.unref();
+child.disconnect();
+setTimeout(() => {
+  console.log('parent exiting');
+  process.exit(0);
+}, 4000);
diff --git a/tests/fixtures/javascript/subprocess-tree/parent_two.js b/tests/fixtures/javascript/subprocess-tree/parent_two.js
new file mode 100644
index 000000000..2969a34e8
--- /dev/null
+++ b/tests/fixtures/javascript/subprocess-tree/parent_two.js
@@ -0,0 +1,25 @@
+/**
+ * A parent with two children at once (issue #1082): two forks of child.js,
+ * both reported on this program's connection and adopted as siblings; the
+ * parent waits for both and exits with the worse of their codes.
+ */
+import { fork } from 'node:child_process';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here = dirname(fileURLToPath(import.meta.url));
+console.log('parent start');
+const children = [0, 1].map(() => fork(join(here, 'child.js'), [], { stdio: 'inherit' }));
+let worst = 0;
+let exited = 0;
+for (const child of children) {
+  child.on('exit', (code) => {
+    worst = Math.max(worst, code ?? 1);
+    exited += 1;
+    console.log(`parent child exit ${code}`);
+    if (exited === children.length) {
+      console.log(`parent done ${worst}`);
+      process.exit(worst);
+    }
+  });
+}

From 8ae86ed27a07b71c06a44336f3126dc29914d5c1 Mon Sep 17 00:00:00 2001
From: JF <john.franklin@gmail.com>
Date: Thu, 5 Nov 2026 19:24:16 -0500
Subject: [PATCH 5/6] fix(session-tree): a js-debug adoption that fails still
 lets the child go, and the fixtures hide their windows (#1082)

An adoption failure under the throwaway lever answered nothing (the report
was acked when held) and the server's release command that follows found the
report already taken, so the fork stayed parked forever. ChildConnections
now lets a taken report's child go by the policy's lever in both places:
release() and the adoption's failure path share giveUp(), which refuses a
debugpy report or runs the throwaway attach for a js-debug one.

The fixtures' fork/spawnSync calls pass windowsHide: true (the #843 guard
scans every tracked script under tests/), and parent_exits.js waits 12 s
before exiting so a slow CI runner can adopt the fork and observe its stop
before the parent ends it (the measured row).

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_015BDrn6AsHQ4rmTXFHzQkn8
---
 src/proxy/child-connections.ts                | 19 +++++++++++++------
 .../javascript-subprocess-tree.test.ts        |  5 +++--
 .../javascript/subprocess-tree/child_grand.js |  2 +-
 .../javascript/subprocess-tree/parent.js      |  2 +-
 .../subprocess-tree/parent_exits.js           |  4 ++--
 .../javascript/subprocess-tree/parent_two.js  |  2 +-
 tests/proxy/child-connections.test.ts         |  7 ++++++-
 7 files changed, 27 insertions(+), 14 deletions(-)

diff --git a/src/proxy/child-connections.ts b/src/proxy/child-connections.ts
index 4c7746fd8..60b396b22 100644
--- a/src/proxy/child-connections.ts
+++ b/src/proxy/child-connections.ts
@@ -153,11 +153,7 @@ export class ChildConnections extends EventEmitter {
       return false;
     }
     this.options.logger.info(`[ChildConnections] Releasing child ${held.report.targetId} (${held.report.name}): ${reason}`);
-    if (this.lever() === 'throwaway-attach') {
-      void this.releaseByThrowaway(held, reason);
-    } else {
-      held.client.respondToReverseRequest?.(held.request, {}, false, reason);
-    }
+    this.giveUp(held, reason);
     return true;
   }
 
@@ -260,7 +256,9 @@ export class ChildConnections extends EventEmitter {
           this.emitEmptyIfSo();
         }
       }
-      this.answer(held, false, `adoption failed: ${message}`);
+      // The report is no longer held, so the server's release command that
+      // follows finds nothing: let the child go here, by the policy's lever.
+      this.giveUp(held, `adoption failed: ${message}`);
       try {
         client?.shutdown(`child adoption failed: ${message}`);
       } catch {
@@ -376,6 +374,15 @@ export class ChildConnections extends EventEmitter {
     held.client.respondToReverseRequest?.(held.request, {}, success, message);
   }
 
+  /** Let a taken report's child run undebugged, by the policy's lever: refuse the request, or attach and detach. */
+  private giveUp(held: HeldReport, reason: string): void {
+    if (this.lever() === 'throwaway-attach') {
+      void this.releaseByThrowaway(held, reason);
+    } else {
+      held.client.respondToReverseRequest?.(held.request, {}, false, reason);
+    }
+  }
+
   /** The policy for a connection opened here: never an in-session adopter (issue #1082). */
   private policyForConnections(deps: ChildAdoptionDeps): AdapterPolicy {
     this.connectionPolicy ??= createChildSafePolicy(deps.policy);
diff --git a/tests/adapters/javascript/integration/javascript-subprocess-tree.test.ts b/tests/adapters/javascript/integration/javascript-subprocess-tree.test.ts
index d236115a5..b9e95546c 100644
--- a/tests/adapters/javascript/integration/javascript-subprocess-tree.test.ts
+++ b/tests/adapters/javascript/integration/javascript-subprocess-tree.test.ts
@@ -298,8 +298,9 @@ describe('JavaScript forks as child sessions (the session tree, issue #1082)', (
     const { sessionId: childId } = await waitForChildStop(rootId, /child\.js$/, CHILD_BREAKPOINT_LINE);
     expect((await rows()).find((row) => row.id === childId)?.state).toBe('paused');
 
-    // The parent exits 4 s after the fork, while the fork is still paused.
-    const listing = await pollUntil(rows, (list) => list.find((row) => row.id === rootId)?.state === 'stopped', 20000);
+    // The parent exits 12 s after the fork (room for a slow CI runner to
+    // adopt and observe the stop first), while the fork is still paused.
+    const listing = await pollUntil(rows, (list) => list.find((row) => row.id === rootId)?.state === 'stopped', 30000);
     expect(listing.find((row) => row.id === rootId)?.state, JSON.stringify(listing)).toBe('stopped');
     const rootOutput = await pollUntil(() => outputText(rootId), (text) => text.includes('parent exiting'), 5000);
     expect(rootOutput).toContain('parent exiting');
diff --git a/tests/fixtures/javascript/subprocess-tree/child_grand.js b/tests/fixtures/javascript/subprocess-tree/child_grand.js
index 2cea529a6..e3035b5d7 100644
--- a/tests/fixtures/javascript/subprocess-tree/child_grand.js
+++ b/tests/fixtures/javascript/subprocess-tree/child_grand.js
@@ -17,7 +17,7 @@ console.log('child start');
 setTimeout(() => {
   const marker = 1; // BREAKPOINT
   console.log(`child step ${marker}`);
-  const result = spawnSync(process.execPath, [join(here, 'grandchild.js')], { stdio: 'inherit' });
+  const result = spawnSync(process.execPath, [join(here, 'grandchild.js')], { stdio: 'inherit', windowsHide: true });
   console.log(`child grandchild exit ${result.status}`);
   process.exit(result.status ?? 1);
 }, 200);
diff --git a/tests/fixtures/javascript/subprocess-tree/parent.js b/tests/fixtures/javascript/subprocess-tree/parent.js
index fe3a068a5..292829bc1 100644
--- a/tests/fixtures/javascript/subprocess-tree/parent.js
+++ b/tests/fixtures/javascript/subprocess-tree/parent.js
@@ -16,7 +16,7 @@ import { fileURLToPath } from 'node:url';
 const here = dirname(fileURLToPath(import.meta.url));
 console.log('parent start');
 const childScript = join(here, process.argv[2] ?? 'child.js'); // argv names another child (child_grand.js)
-const child = fork(childScript, [], { stdio: 'inherit' });
+const child = fork(childScript, [], { stdio: 'inherit', windowsHide: true });
 const marker = child.pid; // BREAKPOINT: the parent pauses here while the child is reported and adopted
 child.on('exit', (code) => {
   console.log(`parent child exit ${code} (${marker})`);
diff --git a/tests/fixtures/javascript/subprocess-tree/parent_exits.js b/tests/fixtures/javascript/subprocess-tree/parent_exits.js
index 58e780435..b3d0d0d32 100644
--- a/tests/fixtures/javascript/subprocess-tree/parent_exits.js
+++ b/tests/fixtures/javascript/subprocess-tree/parent_exits.js
@@ -15,10 +15,10 @@ import { fileURLToPath } from 'node:url';
 
 const here = dirname(fileURLToPath(import.meta.url));
 console.log('parent start');
-const child = fork(join(here, 'child.js'), [], { stdio: 'inherit' });
+const child = fork(join(here, 'child.js'), [], { stdio: 'inherit', windowsHide: true });
 child.unref();
 child.disconnect();
 setTimeout(() => {
   console.log('parent exiting');
   process.exit(0);
-}, 4000);
+}, 12000);
diff --git a/tests/fixtures/javascript/subprocess-tree/parent_two.js b/tests/fixtures/javascript/subprocess-tree/parent_two.js
index 2969a34e8..a31aa23cb 100644
--- a/tests/fixtures/javascript/subprocess-tree/parent_two.js
+++ b/tests/fixtures/javascript/subprocess-tree/parent_two.js
@@ -9,7 +9,7 @@ import { fileURLToPath } from 'node:url';
 
 const here = dirname(fileURLToPath(import.meta.url));
 console.log('parent start');
-const children = [0, 1].map(() => fork(join(here, 'child.js'), [], { stdio: 'inherit' }));
+const children = [0, 1].map(() => fork(join(here, 'child.js'), [], { stdio: 'inherit', windowsHide: true }));
 let worst = 0;
 let exited = 0;
 for (const child of children) {
diff --git a/tests/proxy/child-connections.test.ts b/tests/proxy/child-connections.test.ts
index fbda0a631..a349e395f 100644
--- a/tests/proxy/child-connections.test.ts
+++ b/tests/proxy/child-connections.test.ts
@@ -720,7 +720,7 @@ describe('ChildConnections under the throwaway-attach lever (js-debug, issue #10
     expect(root.respondToReverseRequest).not.toHaveBeenCalled();
   });
 
-  it('an adoption that fails does not refuse the request either, and tears its connection down', async () => {
+  it('an adoption that fails releases the child by the throwaway attach (the acked report cannot be refused), and tears its connection down', async () => {
     root.emit('child-report', { request: jsStartDebugging(7), report: jsReport });
     const adopting = connections.adopt('child-1', { reportId: reported()[0].reportId as string, breakpoints: [] });
     await new Promise((resolve) => setImmediate(resolve));
@@ -731,6 +731,11 @@ describe('ChildConnections under the throwaway-attach lever (js-debug, issue #10
     expect(root.respondToReverseRequest).not.toHaveBeenCalledWith(expect.anything(), expect.anything(), false, expect.anything());
     expect(childClient.shutdown).toHaveBeenCalled();
     expect(connections.has('child-1')).toBe(false);
+    // The server's release command that follows finds nothing held: the
+    // child is let go here, or it stays parked forever.
+    await throwawayRan(releaseClient);
+    expect(releaseClient.sendRequest).toHaveBeenCalledWith('attach', expect.objectContaining({ __pendingTargetId: 'a1b2c3d4e5f60718293a4b5c' }), 15000);
+    expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining('adoption failed: attach refused'));
   });
 
   it('a report during worker shutdown is acked and left parked, with a warning', async () => {

From 6b21788d532dc5fbfb97330f455bea2ad1994e94 Mon Sep 17 00:00:00 2001
From: JF <john.franklin@gmail.com>
Date: Thu, 5 Nov 2026 23:36:59 -0500
Subject: [PATCH 6/6] fix(session-tree): drain child releases and preserve
 attached child output

---
 changelog.d/1094.fixed.md                     |   1 +
 docs/architecture/session-tree.md             |  14 +-
 docs/javascript/README.md                     |   9 ++
 .../shared/src/interfaces/child-adoption.ts   |   4 +-
 src/proxy/child-connections.ts                |  60 +++++---
 src/proxy/dap-proxy-worker.ts                 |   4 +-
 src/proxy/proxy-manager.ts                    |  12 +-
 src/proxy/throwaway-release.ts                | 131 +++++++++---------
 src/server/output-resources.ts                |   5 +-
 src/session/session-manager-core.ts           |   9 +-
 .../core/unit/server/server-resources.test.ts |  30 ++++
 .../session-manager-child-sessions.test.ts    |  11 ++
 tests/proxy/child-connections.test.ts         |  82 ++++++++++-
 .../dap-proxy-worker-child-sessions.test.ts   |  39 +++++-
 tests/unit/proxy/proxy-manager.start.test.ts  |  23 +++
 tests/unit/proxy/throwaway-release.test.ts    | 102 ++++++++++++++
 16 files changed, 435 insertions(+), 101 deletions(-)
 create mode 100644 changelog.d/1094.fixed.md

diff --git a/changelog.d/1094.fixed.md b/changelog.d/1094.fixed.md
new file mode 100644
index 000000000..ad1534ef4
--- /dev/null
+++ b/changelog.d/1094.fixed.md
@@ -0,0 +1 @@
+**JavaScript child release and output** — child releases handle socket failures without crashing the shared worker, stop issuing requests after their deadline, and finish before the root disconnects. Shutdown also drains releases already in flight and newly reported descendants, with enough worker-exit grace for the release handshake. Children of an attached JavaScript process keep their own console output; output resources preserve child-local diagnostics alongside a launch-session output pointer.
diff --git a/docs/architecture/session-tree.md b/docs/architecture/session-tree.md
index eafd700d9..ffa848d5a 100644
--- a/docs/architecture/session-tree.md
+++ b/docs/architecture/session-tree.md
@@ -157,13 +157,17 @@ A child's own buffer carries its own lines **where the adapter can attribute the
 - debugpy can: with `redirectOutput: true` in the child's attach, the child's stdout and stderr
   also arrive on the child's connection. The child's `get_output` and
   `debug://sessions/<child>/output` show the child's lines; the parent's show the tree.
-- js-debug cannot: all output of the tree arrives on the root connection and child sessions carry
+- js-debug launches cannot: all output of the tree arrives on the root connection and child sessions carry
   no `output` events at all. A js-debug child's `get_output` answers with an empty page and a note
   that its output is on the launch session (`outputOn: <launch session id>`); its resource reads
-  the same way.
-
-The attribution is one per-adapter policy pin (below). The per-process-only alternative (each
-session carries only its own process's lines) is not implementable: js-debug offers no
+  the same way, preserving any diagnostics captured in the child's own buffer.
+- js-debug attach roots do not own the process pipes. With the default console capture, each
+  child's console output arrives on its own connection; its `get_output` and resource show those
+  lines, without an `outputOn` pointer. This was measured with an attached Node parent and an
+  adopted fork during the M2 review (js-debug v1.140.0).
+
+The attribution is one per-adapter policy pin (below), applied to launch roots. The per-process-only
+alternative (each session carries only its own process's lines) is not implementable for launches: js-debug offers no
 attribution, and the parent's copy of a debugpy child's lines arrives through the inherited pipe
 with no pid on it.
 
diff --git a/docs/javascript/README.md b/docs/javascript/README.md
index fa273dbac..17acee275 100644
--- a/docs/javascript/README.md
+++ b/docs/javascript/README.md
@@ -208,6 +208,15 @@ to inspect these decisions inside a running mcp-debugger server.
 
 With `autoAttachChildProcesses: true` every Node process the program starts — a `fork()`, a `spawn(process.execPath, …)`, a `cluster` worker, a grandchild — becomes a child debug session of its own (the [session tree](../architecture/session-tree.md), issue [#1082](https://github.com/debugmcp/mcp-debugger/issues/1082), from the facts measured in [spike-notes-forks.md](spike-notes-forks.md)): listed by `list_debug_sessions` with `parentSessionId`, stopping on the breakpoints set on the parent before launch (re-sent to each child before it runs), reported by the parent's `wait_for_stop` with its `sessionId`. Three things js-debug does differently from debugpy, all answered rather than hidden: the whole tree's output arrives on the launch session's buffer and none of it on a child's — a child's `get_output` answers `outputOn: <launch session id>`; `close_debug_session` on a child releases it to run on (`released: true`) because js-debug cannot end a target it adopted; and a child the server does not adopt (beyond `DEBUG_MCP_MAX_CHILD_SESSIONS`, default 32, `0` off) is released by a throwaway attach-then-detach ([#501](https://github.com/debugmcp/mcp-debugger/issues/501)'s lever), since refusing js-debug's report would park it forever. Function breakpoints do not carry into a child (they are armed over CDP on the program's own target); logpoints do, printing into the launch session's output. The program's exit ends every process under it, a child paused on a breakpoint included (measured): the launch owns the tree, so keep the parent alive while you inspect a child.
 
+For an `attach_to_process` root, the default console capture delivers each child's console
+output to that child's own buffer and resource; it does not return an `outputOn` pointer to the
+root. A launch child's output resource still includes any diagnostics recorded for that child
+alongside the pointer to the launch output.
+
+Fork logpoints use a `console.log` fallback because each fork does not have its own CDP logpoint
+bridge. A child that replaces `console.log` can suppress those messages; the program target's
+CDP-backed logpoints are unaffected.
+
 The key still defaults to `false` (the default flips in M2's second PR); pass it explicitly in `dapLaunchArgs`:
 
 ```javascript
diff --git a/packages/shared/src/interfaces/child-adoption.ts b/packages/shared/src/interfaces/child-adoption.ts
index a9fd334a6..920b601ec 100644
--- a/packages/shared/src/interfaces/child-adoption.ts
+++ b/packages/shared/src/interfaces/child-adoption.ts
@@ -44,7 +44,9 @@ export interface ChildAdoptionContract {
   releaseLever: 'reject-request' | 'throwaway-attach';
   /**
    * Where a child's own output lands: on its own connection (debugpy with
-   * `redirectOutput`), or only on the launch session's (js-debug).
+   * `redirectOutput`), or only on the launch session's (js-debug's stdout
+   * capture). Attach roots do not own the process pipes; their children read
+   * their own connections instead (js-debug's default console capture).
    */
   childOutput: 'own-connection' | 'launch-session';
   /**
diff --git a/src/proxy/child-connections.ts b/src/proxy/child-connections.ts
index 60b396b22..1ad70375b 100644
--- a/src/proxy/child-connections.ts
+++ b/src/proxy/child-connections.ts
@@ -101,6 +101,8 @@ export class ChildConnections extends EventEmitter {
   private readonly held = new Map<string, HeldReport>();
   /** Adopted child connections by their session id. */
   private readonly clients = new Map<string, ChildConnection>();
+  /** Releases own sockets too; shutdown must wait until they have detached. */
+  private readonly releases = new Set<Promise<void>>();
   private readonly releaseTimeoutMs: number;
   private closing = false;
   /** The policy the connections opened here run (child-safe for an in-session adopter, issue #1082). */
@@ -136,9 +138,9 @@ export class ChildConnections extends EventEmitter {
     return this.clients.get(sessionId)?.client;
   }
 
-  /** How many adopted child connections are open. */
+  /** How many adopted or releasing child connections are open. */
   liveCount(): number {
-    return this.clients.size;
+    return this.clients.size + this.releases.size;
   }
 
   /**
@@ -157,11 +159,15 @@ export class ChildConnections extends EventEmitter {
     return true;
   }
 
-  /** Release every report still held (worker shutdown). */
-  releaseAllHeld(reason: string): void {
-    for (const reportId of Array.from(this.held.keys())) {
-      this.release(reportId, reason);
-    }
+  /** Release held reports and wait for every throwaway socket before the adapter can be stopped. */
+  async releaseAllHeld(reason: string): Promise<void> {
+    do {
+      for (const reportId of Array.from(this.held.keys())) {
+        this.release(reportId, reason);
+      }
+      await Promise.all(this.releases);
+      // A released process can report another process before it detaches.
+    } while (this.held.size > 0 || this.releases.size > 0);
   }
 
   /**
@@ -253,12 +259,12 @@ export class ChildConnections extends EventEmitter {
         connection.cancelAdoption = undefined;
         if (this.clients.get(childSessionId) === connection) {
           this.clients.delete(childSessionId);
-          this.emitEmptyIfSo();
         }
       }
       // The report is no longer held, so the server's release command that
       // follows finds nothing: let the child go here, by the policy's lever.
       this.giveUp(held, `adoption failed: ${message}`);
+      this.emitEmptyIfSo();
       try {
         client?.shutdown(`child adoption failed: ${message}`);
       } catch {
@@ -314,25 +320,20 @@ export class ChildConnections extends EventEmitter {
   /** Close every adopted connection without ending the children (the worker is going down). */
   async closeAll(reason: string): Promise<void> {
     this.closing = true;
-    this.releaseAllHeld(reason);
+    await this.releaseAllHeld(reason);
     this.options.logger.info(`[ChildConnections] Closing ${this.clients.size} child connection(s): ${reason}`);
     for (const sessionId of Array.from(this.clients.keys())) {
       await this.close(sessionId, { terminateDebuggee: false });
     }
+    await this.releaseAllHeld(reason);
   }
 
   // ----- internals -----
 
   private hold(client: IDapClient, connectionSessionId: string, request: DebugProtocol.Request, report: ChildReport): void {
     const throwaway = this.lever() === 'throwaway-attach';
-    if (this.closing) {
-      if (throwaway) {
-        // The worker is going down with its adapter; nothing can attach to this target any more.
-        this.options.logger.warn(`[ChildConnections] Child ${report.targetId} (${report.name}) reported during worker shutdown stays parked`);
-        client.respondToReverseRequest?.(request, {}, true, undefined);
-      } else {
-        client.respondToReverseRequest?.(request, {}, false, 'worker shutdown');
-      }
+    if (this.closing && !throwaway) {
+      client.respondToReverseRequest?.(request, {}, false, 'worker shutdown');
       return;
     }
     const reportId = randomUUID();
@@ -347,6 +348,10 @@ export class ChildConnections extends EventEmitter {
       // once, now, and never again for this request.
       client.respondToReverseRequest?.(request, {}, true, undefined);
     }
+    if (this.closing) {
+      this.release(reportId, 'worker shutdown');
+      return;
+    }
     this.options.logger.info(
       `[ChildConnections] Holding child ${report.targetId} (${report.name}) reported on session ${connectionSessionId} as ${reportId}`
     );
@@ -377,7 +382,15 @@ export class ChildConnections extends EventEmitter {
   /** Let a taken report's child run undebugged, by the policy's lever: refuse the request, or attach and detach. */
   private giveUp(held: HeldReport, reason: string): void {
     if (this.lever() === 'throwaway-attach') {
-      void this.releaseByThrowaway(held, reason);
+      const releasing = this.releaseByThrowaway(held, reason)
+        .catch((error: unknown) => {
+          this.options.logger.error(`[ChildConnections] Failed to release child ${held.report.targetId}: ${error instanceof Error ? error.message : String(error)}`);
+        })
+        .finally(() => {
+          this.releases.delete(releasing);
+          this.emitEmptyIfSo();
+        });
+      this.releases.add(releasing);
     } else {
       held.client.respondToReverseRequest?.(held.request, {}, false, reason);
     }
@@ -404,12 +417,13 @@ export class ChildConnections extends EventEmitter {
       return;
     }
     const label = held.report.targetId.slice(0, 8);
+    const attachArguments = contract.buildChildAttachArguments(held.report, deps.launchConfig as Readonly<Record<string, unknown>> | undefined);
     const client = deps.dapClientFactory.create(deps.host, deps.port, this.policyForConnections(deps), { traceLabel: `release:${label}` });
     this.attach(client, held.connectionSessionId);
     const released = await releaseByThrowawayAttach({
       client,
       policy: deps.policy,
-      attachArguments: contract.buildChildAttachArguments(held.report, deps.launchConfig as Readonly<Record<string, unknown>> | undefined),
+      attachArguments,
       label,
       logger
     });
@@ -464,11 +478,15 @@ export class ChildConnections extends EventEmitter {
       expected: connection.terminatedSeen || connection.closed
     };
     this.options.messageSender.send(message);
-    this.emitEmptyIfSo();
+    // A cancelled adoption registers its fallback release in its catch.
+    // Let that path announce emptiness, after it owns the replacement socket.
+    if (!connection.cancelAdoption) {
+      this.emitEmptyIfSo();
+    }
   }
 
   private emitEmptyIfSo(): void {
-    if (this.clients.size === 0) {
+    if (this.liveCount() === 0) {
       this.emit('empty');
     }
   }
diff --git a/src/proxy/dap-proxy-worker.ts b/src/proxy/dap-proxy-worker.ts
index b4a6a9b8b..2f09f9325 100644
--- a/src/proxy/dap-proxy-worker.ts
+++ b/src/proxy/dap-proxy-worker.ts
@@ -2423,6 +2423,7 @@ export class DapProxyWorker {
     if (this.isAttachMode && this.state === ProxyState.CONNECTED && this.connectionManager && this.dapClient && !this.dapDisconnectSent) {
       this.logger?.info('[Worker] Attach mode: auto-detaching with terminateDebuggee=false before shutdown.');
       await this.resumeBeforeDetach('close');
+      await this.childConnections?.releaseAllHeld('root detach');
       // The resume may have waited: the adapter can have ended or dropped the
       // socket meanwhile, and a concurrent shutdown may have torn the client down.
       if (this.connectionManager && this.dapClient && !this.dapDisconnectSent) {
@@ -2470,7 +2471,7 @@ export class DapProxyWorker {
 
     // A child still held unanswered would stay parked once this worker is
     // gone (issue #1081): release every held report first, so each runs.
-    this.childConnections?.releaseAllHeld('worker shutdown');
+    await this.childConnections?.releaseAllHeld('worker shutdown');
 
     // Close the mirror before the DAP disconnect so mirror clients receive
     // terminated even if the adapter disconnect eats its 1s cap (#217).
@@ -2767,6 +2768,7 @@ export class DapProxyWorker {
     if (detaching) {
       await this.resumeBeforeDetach('detach');
     }
+    await this.childConnections?.releaseAllHeld('root disconnect');
     if (this.isAttachMode) {
       this.dapDisconnectSent = true;
     }
diff --git a/src/proxy/proxy-manager.ts b/src/proxy/proxy-manager.ts
index e44c7b197..aed6273f7 100644
--- a/src/proxy/proxy-manager.ts
+++ b/src/proxy/proxy-manager.ts
@@ -27,6 +27,7 @@ import type {
   ProxyMessage
 } from '../dap-core/types.js';
 import { DapResponseError } from './dap-response-error.js';
+import { THROWAWAY_RELEASE_TIMEOUT_MS } from './throwaway-release.js';
 import { disposeAdapterQuietly } from '../adapters/adapter-disposal.js';
 import { ErrorMessages, ProxyInitProgress } from '../utils/error-messages.js';
 import { ProxyConfig } from './proxy-config.js';
@@ -39,6 +40,7 @@ import {
   sanitizePayloadForLogging,
   describeDapEventBodyForLog,
   sanitizeStderr,
+  getPolicyForLanguage,
   LineBuffer
 } from '@debugmcp/shared';
 import type { HandshakeProxy } from '@debugmcp/shared';
@@ -276,6 +278,8 @@ export class ProxyManager extends EventEmitter implements IProxyManager {
   private isStopped = false;
   /** Bounded wait for in-flight DAP requests to settle before stop() cancels them. */
   private stopDrainTimeoutMs = 1000;
+  /** Worker exit grace, including any adapter-specific child-release handshake. */
+  private stopTimeoutMs = 5000;
   /** Worker-side DAP request timeout assumed when no per-request override is given. */
   private defaultDapRequestTimeoutMs = 30000;
   /**
@@ -358,6 +362,12 @@ export class ProxyManager extends EventEmitter implements IProxyManager {
     this.exitEmitted = false;
 
     this.sessionId = config.sessionId;
+    // A js-debug release can need its full attach deadline before the worker
+    // disconnects the root. Killing the worker at the ordinary 5s deadline
+    // would strand that child; leave the normal cleanup grace after release.
+    this.stopTimeoutMs = getPolicyForLanguage(config.language).childAdoption?.releaseLever === 'throwaway-attach'
+      ? THROWAWAY_RELEASE_TIMEOUT_MS + 5000
+      : 5000;
     this.isStopped = false;
     this.lastProxyPid = null;
     this.adapterStderrTail = [];
@@ -582,7 +592,7 @@ export class ProxyManager extends EventEmitter implements IProxyManager {
         // accumulate a dead handler on the process object (issue #420).
         process.removeListener('exit', onExit);
         resolve();
-      }, 5000);
+      }, this.stopTimeoutMs);
 
       process.once('exit', onExit);
 
diff --git a/src/proxy/throwaway-release.ts b/src/proxy/throwaway-release.ts
index b6522c029..4b00c4146 100644
--- a/src/proxy/throwaway-release.ts
+++ b/src/proxy/throwaway-release.ts
@@ -40,79 +40,84 @@ export interface ThrowawayReleaseOptions {
 export async function releaseByThrowawayAttach(options: ThrowawayReleaseOptions): Promise<boolean> {
   const { client, policy, attachArguments, label, logger } = options;
   const timeoutMs = options.timeoutMs ?? THROWAWAY_RELEASE_TIMEOUT_MS;
+  let failure: Error | undefined;
+  let timedOut = false;
+  let rejectInterrupted!: (error: Error) => void;
+  const interrupted = new Promise<never>((_, reject) => { rejectInterrupted = reject; });
+  const interrupt = (error: Error): void => {
+    if (failure) return;
+    failure = error;
+    rejectInterrupted(error);
+  };
+  // Own errors for the client's entire lifetime: MinimalDapClient emits a
+  // socket failure after connect, even while an ordinary request is pending.
+  const onError = (error: unknown): void => interrupt(error instanceof Error ? error : new Error(String(error)));
+  const onClose = (): void => interrupt(new Error('release connection closed'));
+  client.on('error', onError);
+  client.on('close', onClose);
+  const deadline = setTimeout(() => {
+    timedOut = true;
+    interrupt(new Error(`release of pending target ${label} timed out`));
+  }, timeoutMs);
+  // Race each step, so timeout/death stops this sequence itself. Merely racing
+  // the outer operation lets a late connect/response continue after shutdown.
+  const wait = <T>(operation: () => Promise<T>): Promise<T> => {
+    if (failure) return Promise.reject(failure);
+    return Promise.race([operation(), interrupted]);
+  };
+  let resolveReady!: () => void;
+  const ready = new Promise<void>((resolve) => { resolveReady = resolve; });
+  const onEvent = (event: DebugProtocol.Event): void => {
+    if (policy.isChildReadyEvent(event)) resolveReady();
+  };
+  let readyTimer: NodeJS.Timeout | undefined;
   try {
-    await withTimeout((async () => {
-      await client.connect();
-      // js-debug rejects launch/attach before initialize; the pending-target
-      // attach handler additionally awaits configurationDone.
-      await client.sendRequest('initialize', {
-        clientID: `mcp-release-${label}`,
-        adapterID: policy.getDapAdapterConfiguration().type,
-        pathFormat: 'path',
-        linesStartAt1: true,
-        columnsStartAt1: true
-      }, INITIALIZE_TIMEOUT_MS);
-      try {
-        await client.sendRequest('configurationDone', {}, CONFIGURATION_DONE_TIMEOUT_MS);
-      } catch {
-        logger.warn(`[release:${label}] configurationDone failed or not required`);
-      }
-      logger.info(`[release:${label}] attach (throwaway connection)`);
-      await client.sendRequest('attach', attachArguments, ATTACH_TIMEOUT_MS);
-      // The resume runs just after the attach response resolves; wait for
-      // the policy's ready signal so a fast disconnect cannot detach from a
-      // target that is still parked.
-      await waitForReadySignal(client, policy, READY_SIGNAL_TIMEOUT_MS);
-      try {
-        await client.sendRequest('disconnect', { terminateDebuggee: false }, DISCONNECT_TIMEOUT_MS);
-      } catch {
-        // Best effort — detaching is what matters, and shutdown() below
-        // closes the socket either way.
-      }
-    })(), timeoutMs, `release of pending target ${label} timed out`);
+    await wait(() => client.connect());
+    // js-debug rejects launch/attach before initialize; the pending-target
+    // attach handler additionally awaits configurationDone.
+    await wait(() => client.sendRequest('initialize', {
+      clientID: `mcp-release-${label}`,
+      adapterID: policy.getDapAdapterConfiguration().type,
+      pathFormat: 'path',
+      linesStartAt1: true,
+      columnsStartAt1: true
+    }, INITIALIZE_TIMEOUT_MS));
+    try {
+      await wait(() => client.sendRequest('configurationDone', {}, CONFIGURATION_DONE_TIMEOUT_MS));
+    } catch (error) {
+      if (failure) throw error;
+      logger.warn(`[release:${label}] configurationDone failed or not required`);
+    }
+    // Listen before attach: the ready event can share a socket chunk with
+    // its response, before the awaiting continuation gets to run.
+    client.on('event', onEvent);
+    logger.info(`[release:${label}] attach (throwaway connection)`);
+    await wait(() => client.sendRequest('attach', attachArguments, ATTACH_TIMEOUT_MS));
+    await wait(() => Promise.race([
+      ready,
+      new Promise<void>((resolve) => { readyTimer = setTimeout(resolve, READY_SIGNAL_TIMEOUT_MS); })
+    ]));
+    try {
+      await wait(() => client.sendRequest('disconnect', { terminateDebuggee: false }, DISCONNECT_TIMEOUT_MS));
+    } catch (error) {
+      if (timedOut) throw error;
+      // Best effort after the resume window: js-debug may close the socket
+      // instead of answering disconnect. shutdown() closes it either way.
+    }
     return true;
   } catch (error) {
     logger.error(`[release:${label}] Failed to release the pending target: ${error instanceof Error ? error.message : String(error)}`);
     return false;
   } finally {
+    clearTimeout(deadline);
+    clearTimeout(readyTimer);
+    client.off('event', onEvent);
     try {
       client.shutdown('release complete');
     } catch {
       // The socket may already be gone.
     }
+    client.off('error', onError);
+    client.off('close', onClose);
   }
 }
-
-/** Resolves true on the policy's child-ready signal, false on timeout or client death. */
-function waitForReadySignal(client: IDapClient, policy: AdapterPolicy, timeoutMs: number): Promise<boolean> {
-  return new Promise<boolean>((resolve) => {
-    let done = false;
-    const settle = (value: boolean): void => {
-      if (done) return;
-      done = true;
-      client.off('event', onEvent);
-      client.off('close', onDeath);
-      client.off('error', onDeath);
-      clearTimeout(timer);
-      resolve(value);
-    };
-    const onEvent = (evt: DebugProtocol.Event): void => {
-      if (evt && policy.isChildReadyEvent(evt)) {
-        settle(true);
-      }
-    };
-    const onDeath = (): void => settle(false);
-    const timer = setTimeout(() => settle(false), timeoutMs);
-    client.on('event', onEvent);
-    client.on('close', onDeath);
-    client.on('error', onDeath);
-  });
-}
-
-function withTimeout<T>(operation: Promise<T>, timeoutMs: number, message: string): Promise<T> {
-  let timer: NodeJS.Timeout | undefined;
-  const timeout = new Promise<never>((_, reject) => {
-    timer = setTimeout(() => reject(new Error(message)), timeoutMs);
-  });
-  return Promise.race([operation, timeout]).finally(() => clearTimeout(timer));
-}
diff --git a/src/server/output-resources.ts b/src/server/output-resources.ts
index ab27c64e5..6e23f1fd6 100644
--- a/src/server/output-resources.ts
+++ b/src/server/output-resources.ts
@@ -173,14 +173,15 @@ export function registerResourceHandlers(
     // A child whose adapter delivers the tree's output on the launch session
     // only (js-debug, issue #1082) reads as a pointer to that resource.
     const outputOn = sessionManager.outputOnFor(session.id);
+    const ownOutput = session.outputBuffer?.renderText() ?? '';
     return {
       contents: [{
         uri,
         mimeType: 'text/plain',
         // Empty until the first launch creates the buffer
         text: outputOn
-          ? `${outputOnNote(outputOn)}\nRead ${outputResourceUri(outputOn)} instead.\n`
-          : session.outputBuffer?.renderText() ?? ''
+          ? `${outputOnNote(outputOn)}\nRead ${outputResourceUri(outputOn)} instead.\n${ownOutput}`
+          : ownOutput
       }]
     };
   });
diff --git a/src/session/session-manager-core.ts b/src/session/session-manager-core.ts
index 49e3266f9..2b99c7b05 100644
--- a/src/session/session-manager-core.ts
+++ b/src/session/session-manager-core.ts
@@ -709,8 +709,8 @@ export abstract class SessionManagerCore extends EventEmitter {
    * tree's root when the adapter delivers the whole tree's output on the
    * launch session's connection and none on the child's (js-debug, the
    * policy's `childOutput: 'launch-session'` pin); undefined when the
-   * session's own buffer is the place to read (a root, or a debugpy child
-   * with its own lines).
+   * session's own buffer is the place to read (a root, a debugpy child,
+   * or a child under an attach root, whose console output is per-target).
    */
   public outputOnFor(sessionId: string): string | undefined {
     const session = this.sessionStore.get(sessionId);
@@ -725,7 +725,10 @@ export abstract class SessionManagerCore extends EventEmitter {
       return undefined;
     }
     const root = this.rootOf(session);
-    return root.id === session.id ? undefined : root.id;
+    // A launch owns the stdout/stderr pipes; an attach does not. js-debug's
+    // default console capture on attach emits on each target's connection,
+    // so pointing at the root would hide the child's actual output.
+    return root.id === session.id || root.attachMode ? undefined : root.id;
   }
 
   /**
diff --git a/tests/core/unit/server/server-resources.test.ts b/tests/core/unit/server/server-resources.test.ts
index 574f56bbd..f5afb6e7b 100644
--- a/tests/core/unit/server/server-resources.test.ts
+++ b/tests/core/unit/server/server-resources.test.ts
@@ -216,6 +216,36 @@ describe('Server Output Resources Tests', () => {
       expect(textOf(result.contents[0])).toBe('');
     });
 
+    it('preserves child diagnostics alongside the pointer to launch-session output', async () => {
+      const session = mockSession({ id: 'child-1' });
+      session.outputBuffer.push('console', '[mcp-debugger] Warning: function breakpoint never bound.\n');
+      mockSessionManager.getSession.mockReturnValue(session);
+      mockSessionManager.outputOnFor.mockReturnValue('root-1');
+
+      const { readResourceHandler } = getResourceHandlers(mockServer);
+      const result = await readResourceHandler({
+        method: 'resources/read',
+        params: { uri: 'debug://sessions/child-1/output' }
+      });
+
+      expect(textOf(result.contents[0])).toContain('debug://sessions/root-1/output');
+      expect(textOf(result.contents[0])).toContain('Warning: function breakpoint never bound.');
+    });
+
+    it('shows an attached child\'s own console output without a launch pointer', async () => {
+      const session = mockSession({ id: 'child-1' });
+      session.outputBuffer.push('stdout', 'child console output\n');
+      mockSessionManager.getSession.mockReturnValue(session);
+
+      const { readResourceHandler } = getResourceHandlers(mockServer);
+      const result = await readResourceHandler({
+        method: 'resources/read',
+        params: { uri: 'debug://sessions/child-1/output' }
+      });
+
+      expect(textOf(result.contents[0])).toBe('child console output\n');
+    });
+
     it('routes proxy-log reads through the bounded sanitizer', async () => {
       const logDir = path.join('/logs', 'sess-1', 'run-123');
       mockSessionManager.getSession.mockReturnValue(mockSession({ logDir }));
diff --git a/tests/core/unit/session/session-manager-child-sessions.test.ts b/tests/core/unit/session/session-manager-child-sessions.test.ts
index 5c1e82501..6354b599c 100644
--- a/tests/core/unit/session/session-manager-child-sessions.test.ts
+++ b/tests/core/unit/session/session-manager-child-sessions.test.ts
@@ -957,5 +957,16 @@ describe('SessionManager child sessions (issue #1081)', () => {
       overridePolicy(sessionManager, { childAdoption: { ...JsDebugAdapterPolicy.childAdoption!, childOutput: 'own-connection' } });
       expect(sessionManager.outputOnFor(childId)).toBeUndefined();
     });
+
+    it('reads child and grandchild output from their own connections under an attach root', async () => {
+      const { rootId, childId, grandchildId, childView } = await jsTree();
+      sessionManager.getSession(rootId)!.attachMode = true;
+      childView.simulateEvent('output', { category: 'stdout', output: 'child console output\n' });
+
+      expect(sessionManager.outputOnFor(childId)).toBeUndefined();
+      expect(sessionManager.outputOnFor(grandchildId)).toBeUndefined();
+      expect(sessionManager.getSession(childId)!.outputBuffer!.renderText()).toContain('child console output');
+      expect(sessionManager.getSession(rootId)!.outputBuffer!.renderText()).not.toContain('child console output');
+    });
   });
 });
diff --git a/tests/proxy/child-connections.test.ts b/tests/proxy/child-connections.test.ts
index a349e395f..31dd19448 100644
--- a/tests/proxy/child-connections.test.ts
+++ b/tests/proxy/child-connections.test.ts
@@ -738,13 +738,89 @@ describe('ChildConnections under the throwaway-attach lever (js-debug, issue #10
     expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining('adoption failed: attach refused'));
   });
 
-  it('a report during worker shutdown is acked and left parked, with a warning', async () => {
+  it('a report during worker shutdown is released without announcing a new session', async () => {
     await connections.closeAll('worker shutdown');
     root.emit('child-report', { request: jsStartDebugging(7), report: jsReport });
 
     expect(reported()).toHaveLength(0);
     expect(root.respondToReverseRequest).toHaveBeenCalledWith(expect.objectContaining({ seq: 7 }), {}, true, undefined);
-    expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining('stays parked'));
-    expect(dapClientFactory.create).not.toHaveBeenCalled();
+    await throwawayRan(releaseClient);
+    expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining('released to run UNDEBUGGED'));
+  });
+
+  it('keeps the worker live and waits for a release already in flight before closing', async () => {
+    let connect!: () => void;
+    releaseClient.connect.mockImplementationOnce(() => new Promise<void>((resolve) => { connect = resolve; }));
+    root.emit('child-report', { request: jsStartDebugging(7), report: jsReport });
+    connections.release(reported()[0].reportId as string, 'over the cap');
+    const empty = vi.fn();
+    connections.on('empty', empty);
+    let closed = false;
+    const closing = connections.closeAll('worker shutdown').then(() => { closed = true; });
+    await new Promise((resolve) => setImmediate(resolve));
+    expect(closed).toBe(false);
+    expect(connections.liveCount()).toBe(1);
+    expect(empty).not.toHaveBeenCalled();
+
+    connect();
+    await throwawayRan(releaseClient);
+    await closing;
+    expect(closed).toBe(true);
+    expect(connections.liveCount()).toBe(0);
+    expect(empty).toHaveBeenCalled();
+  });
+
+  it('does not announce an empty worker between a failed adoption and its release', async () => {
+    root.emit('child-report', { request: jsStartDebugging(7), report: jsReport });
+    const adopting = connections.adopt('child-1', { reportId: reported()[0].reportId as string });
+    await new Promise((resolve) => setImmediate(resolve));
+    const empty = vi.fn();
+    connections.on('empty', empty);
+    rejectAttach(new Error('attach refused'));
+    await expect(adopting).rejects.toThrow('attach refused');
+    expect(empty).not.toHaveBeenCalled();
+    expect(connections.liveCount()).toBe(1);
+
+    await throwawayRan(releaseClient);
+    expect(empty).toHaveBeenCalledOnce();
+  });
+
+  it('contains a release-client construction failure and lets shutdown complete', async () => {
+    dapClientFactory.create.mockImplementationOnce(() => { throw new Error('client unavailable'); });
+    root.emit('child-report', { request: jsStartDebugging(7), report: jsReport });
+    connections.release(reported()[0].reportId as string, 'over the cap');
+    await connections.closeAll('worker shutdown');
+    expect(connections.liveCount()).toBe(0);
+    expect(logger.error).toHaveBeenCalledWith(expect.stringContaining('client unavailable'));
+  });
+
+  it('drains a grandchild reported by a release connection during shutdown', async () => {
+    const grandchildClient = createMockDapClient();
+    dapClientFactory.create.mockReturnValueOnce(releaseClient).mockReturnValueOnce(grandchildClient);
+    releaseClient.sendRequest.mockImplementation(async (command: string) => {
+      if (command === 'attach') {
+        releaseClient.emit('child-report', {
+          request: jsStartDebugging(9),
+          report: { targetId: 'grandchild', name: 'grandchild.js', configuration: { __pendingTargetId: 'grandchild' } }
+        });
+        setImmediate(() => releaseClient.emit('event', { event: 'thread', body: {} }));
+      }
+      return { body: {} };
+    });
+    grandchildClient.sendRequest.mockImplementation(async (command: string) => {
+      if (command === 'attach') {
+        setImmediate(() => grandchildClient.emit('event', { event: 'thread', body: {} }));
+      }
+      return { body: {} };
+    });
+    root.emit('child-report', { request: jsStartDebugging(7), report: jsReport });
+
+    await connections.closeAll('worker shutdown');
+
+    expect(reported()).toHaveLength(1);
+    expect(grandchildClient.sendRequest).toHaveBeenCalledWith('attach', expect.objectContaining({ __pendingTargetId: 'grandchild' }), 15000);
+    expect(grandchildClient.shutdown).toHaveBeenCalledWith('release complete');
+    expect(releaseClient.shutdown).toHaveBeenCalledWith('release complete');
+    expect(connections.liveCount()).toBe(0);
   });
 });
diff --git a/tests/proxy/dap-proxy-worker-child-sessions.test.ts b/tests/proxy/dap-proxy-worker-child-sessions.test.ts
index 80403e62c..50275a6c1 100644
--- a/tests/proxy/dap-proxy-worker-child-sessions.test.ts
+++ b/tests/proxy/dap-proxy-worker-child-sessions.test.ts
@@ -38,6 +38,7 @@ describe('DapProxyWorker child sessions (issue #1081)', () => {
   let mockLogger: ILogger;
   let rootClient: ReturnType<typeof createMockDapClient>;
   let childClient: ReturnType<typeof createMockDapClient>;
+  let releaseClient: ReturnType<typeof createMockDapClient>;
   let processStub: { spawn: Mock; shutdown: Mock };
   let resolveAttach: () => void;
   let send: Mock<(message: SentMessage) => void>;
@@ -84,6 +85,7 @@ describe('DapProxyWorker child sessions (issue #1081)', () => {
     mockLogger = createMockLogger();
     rootClient = createMockDapClient();
     childClient = createMockDapClient();
+    releaseClient = createMockDapClient();
     processStub = {
       spawn: vi.fn().mockResolvedValue({ process: new EventEmitter() as unknown as ChildProcess, pid: 321 }),
       shutdown: vi.fn().mockResolvedValue(undefined)
@@ -108,7 +110,7 @@ describe('DapProxyWorker child sessions (issue #1081)', () => {
       processSpawner: createMockProcessSpawner(),
       dapClientFactory: {
         create: vi.fn((_host: string, _port: number, _policy?: unknown, options?: { traceLabel?: string }) =>
-          options?.traceLabel?.startsWith('child:') ? childClient : rootClient)
+          options?.traceLabel?.startsWith('release:') ? releaseClient : options?.traceLabel?.startsWith('child:') ? childClient : rootClient)
       },
       messageSender: { send }
     };
@@ -307,6 +309,41 @@ describe('DapProxyWorker child sessions (issue #1081)', () => {
     expect(releasedAt).toBeLessThan(disconnectedAt);
   });
 
+  it.each(['shutdown', 'attach close', 'explicit detach'] as const)('%s waits for a js-debug child release before disconnecting the root', async (mode) => {
+    await connectUnder(JsDebugAdapterPolicy);
+    (worker as any).state = ProxyState.CONNECTED;
+    (worker as any).isAttachMode = mode !== 'shutdown';
+    let connect!: () => void;
+    releaseClient.connect.mockImplementationOnce(() => new Promise<void>((resolve) => { connect = resolve; }));
+    releaseClient.sendRequest.mockImplementation(async (command: string) => {
+      if (command === 'attach') {
+        setImmediate(() => releaseClient.emit('event', { event: 'thread', body: { reason: 'started', threadId: 1 } }));
+      }
+      return { body: {} };
+    });
+    const configuration = { type: 'pwa-node', name: 'child.js', __pendingTargetId: 'fork-1' };
+    rootClient.emit('child-report', {
+      request: { seq: 9, type: 'request', command: 'startDebugging', arguments: { request: 'launch', configuration } },
+      report: { targetId: 'fork-1', name: 'child.js', configuration }
+    });
+    const closing = mode === 'explicit detach'
+      ? worker.handleCommand({ cmd: 'dap', sessionId: 'py-root', requestId: 'detach', dapCommand: 'disconnect', dapArgs: { terminateDebuggee: false } })
+      : worker.handleTerminate();
+    await new Promise((resolve) => setImmediate(resolve));
+    expect(releaseClient.connect).toHaveBeenCalled();
+    expect(connectionStub.disconnect).not.toHaveBeenCalled();
+    expect(rootClient.sendRequest).not.toHaveBeenCalledWith('disconnect', expect.anything());
+    expect(processStub.shutdown).not.toHaveBeenCalled();
+
+    connect();
+    await closing;
+    const releasedAt = releaseClient.shutdown.mock.invocationCallOrder[0];
+    const disconnectedAt = mode === 'explicit detach'
+      ? rootClient.sendRequest.mock.invocationCallOrder[rootClient.sendRequest.mock.calls.findIndex(([command]) => command === 'disconnect')]
+      : connectionStub.disconnect.mock.invocationCallOrder[0];
+    expect(releasedAt).toBeLessThan(disconnectedAt);
+  });
+
   it('rejects a request for a child whose connection has ended without sending it to the root', async () => {
     await connectUnder(PythonAdapterPolicy);
     await adoptChild();
diff --git a/tests/unit/proxy/proxy-manager.start.test.ts b/tests/unit/proxy/proxy-manager.start.test.ts
index 110b05d6a..79fec0038 100644
--- a/tests/unit/proxy/proxy-manager.start.test.ts
+++ b/tests/unit/proxy/proxy-manager.start.test.ts
@@ -1049,6 +1049,29 @@ describe('ProxyManager.start', () => {
   });
 
   describe('stop and cleanup behavior', () => {
+    it.each([
+      { language: DebugLanguage.JAVASCRIPT, timeoutMs: 25000 },
+      { language: DebugLanguage.PYTHON, timeoutMs: 5000 }
+    ])('allows $language its child-release and cleanup grace before force killing', async ({ language, timeoutMs }) => {
+      await completeStart({ ...baseConfig, language });
+      vi.useFakeTimers();
+      try {
+        let stopped = false;
+        const stopping = proxyManager.stop().then(() => { stopped = true; });
+
+        await vi.advanceTimersByTimeAsync(timeoutMs - 1);
+        expect(fakeProcess.send).toHaveBeenCalledWith({ cmd: 'terminate', sessionId: baseConfig.sessionId });
+        expect(fakeProcess.kill).not.toHaveBeenCalled();
+        expect(stopped).toBe(false);
+
+        await vi.advanceTimersByTimeAsync(1);
+        await stopping;
+        expect(fakeProcess.kill).toHaveBeenCalledExactlyOnceWith('SIGKILL');
+      } finally {
+        vi.useRealTimers();
+      }
+    });
+
     it('sends terminate and force kills when proxy does not exit in time', async () => {
       vi.useFakeTimers();
       try {
diff --git a/tests/unit/proxy/throwaway-release.test.ts b/tests/unit/proxy/throwaway-release.test.ts
index f841d0e80..42c1c99e7 100644
--- a/tests/unit/proxy/throwaway-release.test.ts
+++ b/tests/unit/proxy/throwaway-release.test.ts
@@ -90,4 +90,106 @@ describe('releaseByThrowawayAttach', () => {
     expect(logger.error).toHaveBeenCalledWith(expect.stringContaining('timed out'));
     expect(client.shutdown).toHaveBeenCalledWith('release complete');
   });
+
+  it('contains a socket error while attach is pending and stops the release', async () => {
+    vi.useFakeTimers();
+    const client = createMockDapClient();
+    client.sendRequest.mockImplementation((command: string) =>
+      command === 'attach' ? new Promise(() => {}) : Promise.resolve({ body: {} })
+    );
+    const releasing = releaseByThrowawayAttach({ client, policy: JsDebugAdapterPolicy, attachArguments, label: 'fork-1', logger });
+    await vi.advanceTimersByTimeAsync(0);
+    expect(client.sendRequest).toHaveBeenCalledWith('attach', attachArguments, 15000);
+
+    // A connected MinimalDapClient emits socket failures on its EventEmitter.
+    // Catch the old uncaught-error behavior so this regression cannot kill Vitest.
+    let uncaught: unknown;
+    try {
+      client.emit('error', new Error('connection reset'));
+    } catch (error) {
+      uncaught = error;
+    }
+    await vi.advanceTimersByTimeAsync(0);
+    const stoppedImmediately = client.shutdown.mock.calls.length > 0;
+    await vi.advanceTimersByTimeAsync(20_000);
+    expect(await releasing).toBe(false);
+    expect(uncaught).toBeUndefined();
+    expect(stoppedImmediately).toBe(true);
+    expect(logger.error).toHaveBeenCalledWith(expect.stringContaining('connection reset'));
+    expect(client.sendRequest).not.toHaveBeenCalledWith('disconnect', expect.anything(), expect.anything());
+    expect(client.listenerCount('error')).toBe(0);
+    expect(client.listenerCount('close')).toBe(0);
+  });
+
+  it('does not continue the sequence when connect finishes after the deadline', async () => {
+    vi.useFakeTimers();
+    const client = createMockDapClient();
+    let finishConnect!: () => void;
+    client.connect.mockImplementation(() => new Promise<void>((resolve) => { finishConnect = resolve; }));
+    const releasing = releaseByThrowawayAttach({ client, policy: JsDebugAdapterPolicy, attachArguments, label: 'fork-1', logger, timeoutMs: 100 });
+    await vi.advanceTimersByTimeAsync(100);
+    expect(await releasing).toBe(false);
+
+    finishConnect();
+    await vi.advanceTimersByTimeAsync(0);
+    const requestsAfterShutdown = client.sendRequest.mock.calls.length;
+    await vi.advanceTimersByTimeAsync(2_000);
+    expect(requestsAfterShutdown).toBe(0);
+    expect(client.sendRequest).not.toHaveBeenCalled();
+    expect(client.shutdown).toHaveBeenCalledTimes(1);
+  });
+
+  it('observes a ready event delivered before the attach response', async () => {
+    vi.useFakeTimers();
+    const client = createMockDapClient();
+    client.sendRequest.mockImplementation(async (command: string) => {
+      if (command === 'attach') {
+        client.emit('event', { event: 'thread', body: { reason: 'started', threadId: 1 } });
+      }
+      return { body: {} };
+    });
+    const releasing = releaseByThrowawayAttach({ client, policy: JsDebugAdapterPolicy, attachArguments, label: 'fork-1', logger });
+    await vi.advanceTimersByTimeAsync(0);
+    const detachedImmediately = client.sendRequest.mock.calls.some(([command]) => command === 'disconnect');
+    await vi.advanceTimersByTimeAsync(1_500);
+
+    expect(await releasing).toBe(true);
+    expect(detachedImmediately).toBe(true);
+    expect(client.listenerCount('event')).toBe(0);
+  });
+
+  it('stops on connection close during configuration instead of attempting attach', async () => {
+    vi.useFakeTimers();
+    const client = createMockDapClient();
+    client.sendRequest.mockImplementation((command: string) =>
+      command === 'configurationDone' ? new Promise(() => {}) : Promise.resolve({ body: {} })
+    );
+    const releasing = releaseByThrowawayAttach({ client, policy: JsDebugAdapterPolicy, attachArguments, label: 'fork-1', logger });
+    await vi.advanceTimersByTimeAsync(0);
+    client.emit('close');
+    await vi.advanceTimersByTimeAsync(0);
+
+    expect(await releasing).toBe(false);
+    expect(client.sendRequest.mock.calls.map(([command]) => command)).toEqual(['initialize', 'configurationDone']);
+    expect(client.shutdown).toHaveBeenCalledTimes(1);
+    expect(vi.getTimerCount()).toBe(0);
+  });
+
+  it.each(['error', 'close'])('contains a socket %s during the best-effort disconnect', async (event) => {
+    const client = createMockDapClient();
+    client.sendRequest.mockImplementation(async (command: string) => {
+      if (command === 'attach') {
+        client.emit('event', { event: 'thread', body: { reason: 'started', threadId: 1 } });
+      } else if (command === 'disconnect') {
+        setImmediate(() => client.emit(event, new Error('disconnected')));
+        return new Promise(() => {});
+      }
+      return { body: {} };
+    });
+
+    expect(await releaseByThrowawayAttach({ client, policy: JsDebugAdapterPolicy, attachArguments, label: 'fork-1', logger })).toBe(true);
+    expect(client.shutdown).toHaveBeenCalledTimes(1);
+    expect(client.listenerCount('error')).toBe(0);
+    expect(client.listenerCount('close')).toBe(0);
+  });
 });