chainlesschain 0.165.5 → 0.165.6

package/src/commands/session-message.js

@@ -0,0 +1,171 @@
+import { logger } from "../lib/logger.js";
+import { SessionMessageFabric } from "../lib/session-message-fabric.js";
+
+function output(value, options = {}) {
+  if (options.json) {
+    logger.log(JSON.stringify(value, null, 2));
+    return;
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      logger.log("No session messages.");
+      return;
+    }
+    for (const item of value) logger.log(JSON.stringify(item));
+    return;
+  }
+  logger.log(JSON.stringify(value, null, 2));
+}
+
+function numericOption(value) {
+  if (value == null) return null;
+  const number = Number(value);
+  return Number.isSafeInteger(number) && number > 0 ? number : value;
+}
+
+function fabric() {
+  return new SessionMessageFabric();
+}
+
+export function registerSessionMessageCommands(session) {
+  const message = session
+    .command("message")
+    .description(
+      "Durable cross-session inbox, addressing, policy and receipts",
+    );
+
+  message
+    .command("register <session-id>")
+    .description("Register or reconnect a uniquely named session endpoint")
+    .option("--name <name>", "Unique @name (defaults to session id)")
+    .option("--machine <id>", "Stable machine identity", "local")
+    .option(
+      "--policy <policy>",
+      "Inbound policy: accept | hold | refuse",
+      "accept",
+    )
+    .option("--busy", "Register as busy instead of idle")
+    .option("--json", "Output as JSON")
+    .action((sessionId, options) => {
+      output(
+        fabric().register({
+          sessionId,
+          name: options.name || sessionId,
+          machineId: options.machine,
+          policy: options.policy,
+          idle: options.busy !== true,
+        }),
+        options,
+      );
+    });
+
+  message
+    .command("unregister <endpoint>")
+    .description("Retire an endpoint epoch without leaking its inbox to reuse")
+    .option("--json", "Output as JSON")
+    .action((endpoint, options) => {
+      output(
+        { unregistered: fabric().unregister(endpoint), endpoint },
+        options,
+      );
+    });
+
+  message
+    .command("send <from> <to> <body...>")
+    .description("Send one bounded, idempotent message and print its receipt")
+    .option("--subject <text>", "Optional bounded subject")
+    .option("--message-id <id>", "Stable idempotency key")
+    .option("--sequence <n>", "Per sender/recipient ordering sequence")
+    .option("--ttl-ms <n>", "Message expiry in milliseconds")
+    .option(
+      "--notify-when-idle",
+      "Emit one receipt update when target becomes idle",
+    )
+    .option("--json", "Output as JSON")
+    .action((from, to, body, options) => {
+      output(
+        fabric().send({
+          from,
+          to,
+          body: body.join(" "),
+          subject: options.subject,
+          messageId: options.messageId,
+          sequence: numericOption(options.sequence),
+          ttlMs: numericOption(options.ttlMs),
+          notifyWhenIdle: options.notifyWhenIdle === true,
+        }),
+        options,
+      );
+    });
+
+  message
+    .command("inbox <endpoint>")
+    .description("Read an endpoint inbox in sender sequence order")
+    .option("--ack", "Acknowledge and release returned live message bodies")
+    .option("--json", "Output as JSON")
+    .action((endpoint, options) => {
+      output(fabric().inbox(endpoint, { acknowledge: options.ack }), options);
+    });
+
+  message
+    .command("receipts <endpoint>")
+    .description("List durable delivered/refused/full/expired receipts")
+    .option("--json", "Output as JSON")
+    .action((endpoint, options) => {
+      output(fabric().receipts(endpoint), options);
+    });
+
+  message
+    .command("policy <endpoint> <policy>")
+    .description("Set accept, hold or refuse with optional revision CAS")
+    .option("--expected-revision <n>", "Reject a stale rendered policy action")
+    .option("--json", "Output as JSON")
+    .action((endpoint, policy, options) => {
+      output(
+        fabric().setPolicy(endpoint, policy, {
+          expectedRevision: numericOption(options.expectedRevision),
+        }),
+        options,
+      );
+    });
+
+  message
+    .command("idle <endpoint> <state>")
+    .description("Set idle/busy and deliver notify_when_idle exactly once")
+    .option("--expected-revision <n>", "Reject a stale rendered idle action")
+    .option("--json", "Output as JSON")
+    .action((endpoint, state, options) => {
+      const normalized = String(state).trim().toLowerCase();
+      if (!["idle", "busy", "true", "false"].includes(normalized)) {
+        const error = new Error("state must be idle, busy, true or false");
+        error.code = "SESSION_MESSAGE_INVALID_ARGUMENT";
+        throw error;
+      }
+      output(
+        fabric().setIdle(endpoint, ["idle", "true"].includes(normalized), {
+          expectedRevision: numericOption(options.expectedRevision),
+        }),
+        options,
+      );
+    });
+
+  for (const action of ["disconnect", "reconnect"]) {
+    message
+      .command(`${action} <endpoint>`)
+      .description(
+        action === "disconnect"
+          ? "Mark transport offline while retaining its durable inbox"
+          : "Mark a durable endpoint transport online again",
+      )
+      .option("--json", "Output as JSON")
+      .action((endpoint, options) => {
+        output({ endpoint, [action]: fabric()[action](endpoint) }, options);
+      });
+  }
+
+  message
+    .command("status")
+    .description("Emit the bounded CLI-owned message projection")
+    .option("--json", "Output as JSON")
+    .action((options) => output(fabric().projection(), options));
+}

package/src/commands/session.js

@@ -68,6 +68,7 @@ import { registerSessionShowSubcommand } from "./session-show.js";
 import { registerSessionObservabilitySubcommand } from "./session-observability.js";
 import { registerSessionLocationSubcommands } from "./session-location.js";
 import { registerSessionBudgetCommands } from "./session-budget.js";
+import { registerSessionMessageCommands } from "./session-message.js";
 
 export const _deps = {
   execFileSync: (...args) => executionBroker.execFileSync(...args),
@@ -226,6 +227,7 @@ export function registerSessionCommand(program) {
   registerSessionMcpRecoveryCommands(session);
   registerSessionLocationSubcommands(session);
   registerSessionBudgetCommands(session);
+  registerSessionMessageCommands(session);
 
   // session list
   session
@@ -321,6 +323,7 @@ export function registerSessionCommand(program) {
         let team = [];
         let workflow = [];
         let dynamicWorkflow = [];
+        let sessionMessageFabric = null;
         let artifacts = [];
         let prLinks = {};
 
@@ -462,6 +465,13 @@ export function registerSessionCommand(program) {
         } catch {
           // Summaries are optional; absence never removes a session.
         }
+        try {
+          const { SessionMessageFabric } =
+            await import("../lib/session-message-fabric.js");
+          sessionMessageFabric = new SessionMessageFabric().projection();
+        } catch (error) {
+          sourceErrors.sessionMessageFabric = error?.message || String(error);
+        }
 
         const { buildSessionProjection } =
           await import("../lib/session-projection.js");
@@ -474,6 +484,7 @@ export function registerSessionCommand(program) {
           dynamicWorkflow,
           artifacts,
           prLinks,
+          sessionMessageFabric,
           sourceErrors,
         });
         if (options.json) {

package/src/data/changelog.json

@@ -1,16 +1,29 @@
 {
   "source": "CHANGELOG.md",
   "releases": [
+    {
+      "productVersion": null,
+      "cliVersion": "0.165.6",
+      "cliVersions": ["0.165.5", "0.165.6"],
+      "date": "2026-08-21",
+      "title": "",
+      "sections": [
+        {
+          "heading": "Added - cc CLI 0.165.6: safer remote sessions and governed plugin sources",
+          "body": "> `chainlesschain` **0.165.5 -> 0.165.6** (candidate; not yet published,\n> 2026-08-21).\n> CLI-only release; `@chainlesschain/personal-data-hub` remains **0.4.59**\n> and `@chainlesschain/agent-sdk` remains **0.1.7**.\n\n- **Remote Control safe defaults**: direct sessions bind to loopback by\n  default. Trusted-LAN exposure requires explicit command authority, preserves\n  the selected bind address, fails closed on relay/direct fallback, and keeps\n  IDE pairing surfaces from presenting loopback endpoints as phone-ready QR\n  links.\n- **Governed plugin source identity**: managed Marketplace policy now evaluates\n  canonical Git, registry, file, alias, ref, path, host, port, principal, and\n  registry-resolution identities before target I/O or process spawn. Clone\n  execution is isolated from ambient Git/SSH configuration, and cache\n  provenance remains bound to the approved source and registry document.\n- **Digest-pinned Marketplace archives**: registry install and update can\n  materialize same-origin, catalog-bound `tgz`/`tar.gz` sources only after\n  candidate preflight. SHA-256 verification and bounded extraction reject\n  traversal, links, special entries, case collisions, and expansion bombs;\n  archive and extracted-payload digest authority are revalidated for offline\n  cache replay. Dynamic command and headers-helper sources remain disabled by\n  product policy.\n- **Cross-platform policy enforcement**: Windows runner temporary roots are\n  canonicalized without probing caller-controlled targets. Other existing 8.3\n  spellings resolve to their long-path authority, while unresolved or forged\n  aliases remain rejected. Linux, Windows, and macOS Marketplace campaigns\n  exercise air-gapped cache, proxy, PAC, and private-registry boundaries.\n- **Durable session and MCP lifecycle**: cross-session messaging, bounded\n  long-running live state, MCP reconnect subscription recovery, lifecycle\n  compatibility, and structured headless observability now share explicit\n  identity, cleanup, and backpressure contracts.\n- **Focused terminal ergonomics**: the `concise` output style and persisted\n  `classic`/`readline` keybinding flavor extend interactive use without\n  changing existing default behavior.\n- **Release status**: publication requires the final candidate commit to pass\n  the complete Linux, Windows, and macOS `CLI CI` and `CLI Strict Sandbox`\n  matrices. The immutable npm tag, provenance, and registry readback will be\n  recorded only after those exact-SHA gates succeed."
+        }
+      ]
+    },
     {
       "productVersion": null,
       "cliVersion": "0.165.5",
       "cliVersions": ["0.165.4", "0.165.5"],
-      "date": "2026-08-20",
+      "date": "2026-08-21",
       "title": "",
       "sections": [
         {
           "heading": "Added - cc CLI 0.165.5: governed recovery and native add-on policy",
-          "body": "> `chainlesschain` **0.165.4 -> 0.165.5** (candidate; not yet published,\n> 2026-08-20).\n> CLI-only release; `@chainlesschain/personal-data-hub` remains **0.4.59**\n> and `@chainlesschain/agent-sdk` remains **0.1.7**.\n\n- **Recoverable Artifact workflows**: inspect and settle orphaned Artifact\n  writes through a bounded CLI-owned recovery projection, retain exact\n  access/deletion evidence, and surface workbench state without letting IDE\n  clients derive storage mutations.\n- **Durable workflow recovery**: plan and resume interrupted workflow stages\n  through persisted authority and checkpoint evidence, with tighter session\n  and execution-location projections for CLI, WebSocket, and IDE consumers.\n- **Native MCP add-on policy**: admit only supported native loader shapes and\n  validated executable/package identities. Unsupported or ambiguous native\n  add-ons now return typed fail-closed rejections instead of crossing the\n  strict process boundary.\n- **Release-candidate gates**: add cross-host Marketplace, accessibility,\n  execution-location, context/permission, and live-provider campaigns while\n  keeping CI dependency installation clean and deterministic.\n- **Release status**: publication requires this exact candidate commit to pass\n  the complete Linux, Windows, and macOS `CLI CI` and `CLI Strict Sandbox`\n  matrices. The immutable npm tag and registry readback will be recorded only\n  after those gates succeed."
+          "body": "> `chainlesschain` **0.165.4 -> 0.165.5** (published from exact SHA\n> `11aef634aa3ab88994698eca0ce2f5cfa65faf48`, 2026-08-21).\n> CLI-only release; `@chainlesschain/personal-data-hub` remains **0.4.59**\n> and `@chainlesschain/agent-sdk` remains **0.1.7**.\n\n- **Recoverable Artifact workflows**: inspect and settle orphaned Artifact\n  writes through a bounded CLI-owned recovery projection, retain exact\n  access/deletion evidence, and surface workbench state without letting IDE\n  clients derive storage mutations.\n- **Durable workflow recovery**: plan and resume interrupted workflow stages\n  through persisted authority and checkpoint evidence, with tighter session\n  and execution-location projections for CLI, WebSocket, and IDE consumers.\n- **Native MCP add-on policy**: admit only supported native loader shapes and\n  validated executable/package identities. Unsupported or ambiguous native\n  add-ons now return typed fail-closed rejections instead of crossing the\n  strict process boundary.\n- **Release gates**: add cross-host Marketplace, accessibility,\n  execution-location, context/permission, and live-provider campaigns while\n  keeping CI dependency installation clean and deterministic.\n- **Published release evidence**: immutable tag `v-npm-0-165-5`, three-OS\n  `CLI CI` (`32413582642`), `CLI Strict Sandbox` (`32413582490`), npm release\n  (`32428314006`), and independent registry/provenance readback\n  (`32429710720`) all bind exact SHA `11aef634aa`. npm reports\n  `latest=0.165.5`; the public tarball SHA-1 is\n  `c2cc7fb18ea572749d747de02355c6a0a5aef357`."
         }
       ]
     },

package/src/harness/mcp-client.js

@@ -45,6 +45,11 @@ import {
   prepareMcpStdioExecutableIdentity,
 } from "../lib/mcp-stdio-executable-identity.js";
 import { resolveMcpStdioSandboxContext } from "../lib/mcp-stdio-workspace-authority.js";
+import {
+  closeMcpTlsDispatcher,
+  createMcpTlsDispatcher,
+  loadMcpTlsMaterial,
+} from "../lib/mcp-tls.js";
 
 /**
  * Injectable dependencies — overridable from tests.
@@ -63,6 +68,9 @@ export const _deps = {
   verifyMcpStdioApprovedWorkingDirectory,
   prepareMcpStdioExecutableIdentity,
   resolveMcpStdioSandboxContext,
+  loadMcpTlsMaterial,
+  createMcpTlsDispatcher,
+  closeMcpTlsDispatcher,
   // Backoff sleep seam (tests override with a no-op so retries don't wait).
   sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
 };
@@ -230,6 +238,24 @@ const MCP_HTTP_RESPONSE_MAX_BYTES = 16 * 1024 * 1024;
  */
 const STDIO_REQUEST_TIMEOUT_MS = 30000;
 const MCP_PROTOCOL_VERSION = "2025-11-25";
+export const SUPPORTED_MCP_PROTOCOL_VERSIONS = Object.freeze([
+  "2024-11-05",
+  "2025-03-26",
+  "2025-06-18",
+  MCP_PROTOCOL_VERSION,
+]);
+const supportedMcpProtocolVersions = new Set(SUPPORTED_MCP_PROTOCOL_VERSIONS);
+
+export function assertSupportedMcpProtocolVersion(value) {
+  if (typeof value !== "string" || !supportedMcpProtocolVersions.has(value)) {
+    const error = new Error(
+      "MCP server selected an unsupported protocol version",
+    );
+    error.code = "CC_MCP_PROTOCOL_VERSION_UNSUPPORTED";
+    throw error;
+  }
+  return value;
+}
 const URL_ELICITATION_REQUIRED = -32042;
 const MCP_RPC_ERROR_CODE = "CC_MCP_RPC_ERROR";
 const mcpRpcControlData = new WeakMap();
@@ -1287,6 +1313,10 @@ export class MCPClient extends EventEmitter {
     this._nextId = 1;
     this._reconnectors = new Map(); // name → async () => config|null
     this._reconnecting = new Map(); // name → in-flight reconnect promise
+    // Desired resource subscriptions outlive a single transport entry. Keeping
+    // them on the client lets a later reconnect retry restoration even when a
+    // previous partial reconnect was torn down fail-closed.
+    this._resourceSubscriptions = new Map(); // name → Set<uri>
     this._sessionId =
       options && options.sessionId != null ? String(options.sessionId) : null;
     this._workspaceBinding =
@@ -2082,6 +2112,17 @@ export class MCPClient extends EventEmitter {
         };
       }
     }
+    let tlsMaterial = null;
+    if (sourceConfig.tls != null) {
+      if (transportKind !== "https" && transportKind !== "wss") {
+        throw mcpTransportError(
+          "CC_MCP_TLS_TRANSPORT_REQUIRED",
+          `MCP TLS configuration requires https or wss (server "${name}")`,
+          { transport: transportKind, url: sourceConfig.url },
+        );
+      }
+      tlsMaterial = _deps.loadMcpTlsMaterial(sourceConfig.tls);
+    }
     const connectionHeaders = await this._connectionHeaders(
       name,
       sourceConfig,
@@ -2104,6 +2145,8 @@ export class MCPClient extends EventEmitter {
       _httpRequestControllers: new Set(),
       _httpDiscardControllers: new Set(),
       _httpDiscardStopping: false,
+      _httpDispatcher: null,
+      _tlsIdentityDigest: tlsMaterial?.identityDigest || null,
       _disconnectPromise: null,
       _webSocketPayloadError: null,
       _webSocketInboundError: null,
@@ -2157,6 +2200,9 @@ export class MCPClient extends EventEmitter {
         }
         entry.httpUrl = config.url;
         entry.httpHeaders = connectionHeaders;
+        entry._httpDispatcher = tlsMaterial
+          ? _deps.createMcpTlsDispatcher(tlsMaterial)
+          : null;
       } else if (isWebSocketTransport(transportKind)) {
         if (!config.url) {
           throw mcpTransportError(
@@ -2203,6 +2249,7 @@ export class MCPClient extends EventEmitter {
           ...(transportKind === "wss" && config.rejectUnauthorized === false
             ? { rejectUnauthorized: false }
             : {}),
+          ...(tlsMaterial?.connectOptions || {}),
         });
         entry.socket = socket;
 
@@ -2680,8 +2727,8 @@ export class MCPClient extends EventEmitter {
         clientInfo: { name: "chainlesschain-cli", version: "0.37.9" },
       });
 
-      entry.protocolVersion = String(
-        initResult?.protocolVersion || this._protocolVersion,
+      entry.protocolVersion = assertSupportedMcpProtocolVersion(
+        initResult?.protocolVersion,
       );
       // Send initialized notification
       this._sendNotification(name, "notifications/initialized", {});
@@ -2831,6 +2878,12 @@ export class MCPClient extends EventEmitter {
           // teardown is best-effort
         }
       }
+      try {
+        await _deps.closeMcpTlsDispatcher(entry._httpDispatcher);
+      } catch {
+        // Preserve the connection failure; dispatcher cleanup is best-effort.
+      }
+      entry._httpDispatcher = null;
       this._releaseToolInventory(entry);
       this.servers.delete(name);
       if (
@@ -2850,7 +2903,10 @@ export class MCPClient extends EventEmitter {
   /**
    * Disconnect from an MCP server.
    */
-  disconnect(name) {
+  disconnect(name, options = {}) {
+    if (options.preserveResourceSubscriptions !== true) {
+      this._resourceSubscriptions.delete(name);
+    }
     const entry = this.servers.get(name);
     if (!entry) {
       this._cancelServerElicitations(name);
@@ -2906,6 +2962,12 @@ export class MCPClient extends EventEmitter {
         }
         return true;
       } finally {
+        try {
+          await _deps.closeMcpTlsDispatcher(entry._httpDispatcher);
+        } catch {
+          // Transport teardown remains best-effort.
+        }
+        entry._httpDispatcher = null;
         entry.state = ServerState.DISCONNECTED;
         this._releaseToolInventory(entry);
         // A future connection may reuse the same name. Never let a delayed
@@ -2928,8 +2990,15 @@ export class MCPClient extends EventEmitter {
    */
   async disconnectAll() {
     const names = [...this.servers.keys()];
-    for (const name of names) {
-      await this.disconnect(name);
+    try {
+      for (const name of names) {
+        await this.disconnect(name);
+      }
+    } finally {
+      // A failed reconnect may have already removed its transport entry while
+      // retaining desired subscriptions for another retry. disconnectAll()
+      // is the explicit terminal teardown and must clear those tombstones too.
+      this._resourceSubscriptions.clear();
     }
   }
 
@@ -3173,11 +3242,22 @@ export class MCPClient extends EventEmitter {
       try {
         const currentEntry = this.servers.get(name) || null;
         const currentConfig = currentEntry?.config || null;
+        // Resource subscriptions belong to the logical client/server
+        // relationship, not to one transport connection. Snapshot them before
+        // disconnect() removes the old entry so a hot reconnect cannot
+        // silently stop delivering resource update notifications.
+        const resourceSubscriptions = new Set([
+          ...(this._resourceSubscriptions.get(name) || []),
+          ...(currentEntry?.resourceSubscriptions || []),
+        ]);
+        if (resourceSubscriptions.size > 0) {
+          this._resourceSubscriptions.set(name, new Set(resourceSubscriptions));
+        }
         const resolver = this._reconnectors.get(name);
         const fresh = resolver ? await resolver() : currentConfig;
         if (!fresh) return false;
         try {
-          await this.disconnect(name);
+          await this.disconnect(name, { preserveResourceSubscriptions: true });
         } catch {
           // entry may already be gone — connect() below is what matters
         }
@@ -3195,6 +3275,25 @@ export class MCPClient extends EventEmitter {
           reconnectConfig,
           options.connectAuthRetryUsed === true,
         );
+        try {
+          for (const uri of resourceSubscriptions) {
+            await this.subscribeResource(name, uri);
+          }
+        } catch {
+          // A partially restored connection is unsafe: callers would believe
+          // the reconnect recovered their live subscriptions while some were
+          // already lost. Tear it down and let the original operation surface
+          // its connection error.
+          try {
+            await this.disconnect(name, {
+              preserveResourceSubscriptions: true,
+            });
+          } catch {
+            // The outer reconnect result remains fail-closed even if cleanup
+            // itself reports an error.
+          }
+          return false;
+        }
         this.emit("server-reconnected", { name, url: fresh.url || null });
         return true;
       } catch {
@@ -3269,9 +3368,23 @@ export class MCPClient extends EventEmitter {
   async subscribeResource(serverName, uri) {
     const entry = this.servers.get(serverName);
     if (!entry) throw new Error(`Server "${serverName}" not found`);
-    await this._sendRequest(serverName, "resources/subscribe", { uri });
+    if (typeof uri !== "string" || !uri.trim()) {
+      throw new TypeError(
+        "MCP resource subscription URI must be a non-empty string",
+      );
+    }
+    const normalizedUri = uri;
+    await this._sendRequest(serverName, "resources/subscribe", {
+      uri: normalizedUri,
+    });
     entry.resourceSubscriptions ||= new Set();
-    entry.resourceSubscriptions.add(String(uri));
+    entry.resourceSubscriptions.add(normalizedUri);
+    let desired = this._resourceSubscriptions.get(serverName);
+    if (!desired) {
+      desired = new Set();
+      this._resourceSubscriptions.set(serverName, desired);
+    }
+    desired.add(normalizedUri);
     return true;
   }
 
@@ -3279,8 +3392,19 @@ export class MCPClient extends EventEmitter {
   async unsubscribeResource(serverName, uri) {
     const entry = this.servers.get(serverName);
     if (!entry) throw new Error(`Server "${serverName}" not found`);
-    await this._sendRequest(serverName, "resources/unsubscribe", { uri });
-    entry.resourceSubscriptions?.delete(String(uri));
+    if (typeof uri !== "string" || !uri.trim()) {
+      throw new TypeError(
+        "MCP resource subscription URI must be a non-empty string",
+      );
+    }
+    const normalizedUri = uri;
+    await this._sendRequest(serverName, "resources/unsubscribe", {
+      uri: normalizedUri,
+    });
+    entry.resourceSubscriptions?.delete(normalizedUri);
+    const desired = this._resourceSubscriptions.get(serverName);
+    desired?.delete(normalizedUri);
+    if (desired?.size === 0) this._resourceSubscriptions.delete(serverName);
     return true;
   }
 
@@ -3752,6 +3876,9 @@ export class MCPClient extends EventEmitter {
                 ...(stream.controller
                   ? { signal: stream.controller.signal }
                   : {}),
+                ...(entry._httpDispatcher
+                  ? { dispatcher: entry._httpDispatcher }
+                  : {}),
               }),
               stream.controller?.signal,
             );
@@ -3997,6 +4124,9 @@ export class MCPClient extends EventEmitter {
             headers,
             body,
             ...(controller ? { signal: controller.signal } : {}),
+            ...(entry._httpDispatcher
+              ? { dispatcher: entry._httpDispatcher }
+              : {}),
           });
         },
       );
@@ -4729,6 +4859,7 @@ async function _fetchAndDiscardHttpResponse(entry, options) {
     const response = await _deps.fetch(entry.httpUrl, {
       ...options,
       ...(controller ? { signal: controller.signal } : {}),
+      ...(entry._httpDispatcher ? { dispatcher: entry._httpDispatcher } : {}),
     });
     _cancelHttpResponseBody(response);
     if (timedOut) {