claude-code-swarm 0.3.25 → 0.4.0

package/src/cascade-diff-server.mjs

@@ -0,0 +1,326 @@
+/**
+ * cascade-diff-server.mjs — services `cascade/diff.request` notifications.
+ *
+ * Phase 3 of cascade integration. The OpenHive hub fetches unified diffs from
+ * the cc-swarm sidecar on demand so its cascade changelog/diff endpoints work
+ * for cc-swarm-tracked streams. Flow:
+ *
+ *   1. Hub sends `cascade/diff.request` with `request_id`, `stream_id`,
+ *      `head`, optional `base` / `file_paths` / `files_only`.
+ *   2. This handler shells out to plain `git show` / `git diff` in the repo
+ *      cwd and produces a unified-diff blob (or a name-only list when
+ *      `files_only: true`).
+ *   3. Response is emitted as a `cascade/diff.response` notification —
+ *      inline when ≤ 512 KB, streamed via N `cascade/diff.chunk`
+ *      notifications when larger.
+ *
+ * cc-swarm runs git-cascade in **local mode** — there are no worktrees. The
+ * `head` / `base` in the request are commit hashes and self-identifying, so
+ * stream → diff resolution is just `git` against the single repo cwd; the
+ * `stream_id` is validated against the tracker but never used to pick a path.
+ *
+ * The 50 MB raw cap (`MAX_DIFF_BYTES`) defends against runaway monorepo
+ * diffs. Errors fold into the same `cascade/diff.response` method via the
+ * `error` shape — this handler never throws.
+ */
+
+import { spawn } from "child_process";
+import { createHash, randomBytes } from "crypto";
+import { createLogger } from "./log.mjs";
+
+const log = createLogger("cascade-diff");
+
+const REQUEST_METHOD = "cascade/diff.request";
+const RESPONSE_METHOD = "cascade/diff.response";
+const CHUNK_METHOD = "cascade/diff.chunk";
+
+/** Reply inline when the raw diff is at or below this size. */
+const INLINE_THRESHOLD_BYTES = 512 * 1024;
+/** Per-chunk payload size for streamed diffs (mirrors sync-client STREAM_CHUNK_SIZE). */
+const CHUNK_SIZE_BYTES = 1024 * 1024;
+/** Hard cap on captured git stdout — defends against runaway monorepo diffs. */
+const MAX_DIFF_BYTES = 50 * 1024 * 1024;
+/** Kill the git spawn after this long. */
+const GIT_TIMEOUT_MS = 30_000;
+
+/**
+ * Register the `cascade/diff.request` handler on a MAP connection.
+ *
+ * @param {object} connection  MAP AgentConnection — must expose
+ *   `onNotification(method, handler)` and `sendNotification(method, params)`.
+ * @param {object} opts
+ * @param {string} opts.repoPath  Path to the git repository (the swarm cwd).
+ * @param {object} [opts.tracker] git-cascade tracker — used only to validate
+ *   that `stream_id` is known; diff resolution never needs it.
+ * @returns {Function} A dispose function — best-effort, never throws.
+ */
+export function setupCascadeDiffServer(connection, { repoPath, tracker } = {}) {
+  if (!connection || typeof connection.onNotification !== "function") {
+    log.debug("cascade diff server skipped: no MAP connection");
+    return () => {};
+  }
+  if (typeof connection.sendNotification !== "function") {
+    log.debug("cascade diff server skipped: connection cannot sendNotification");
+    return () => {};
+  }
+
+  const handler = async (params) => {
+    const req = params || null;
+    if (!req || typeof req.request_id !== "string" || !req.request_id) return;
+    if (!req.stream_id || !req.head) {
+      sendError(connection, req.request_id, "bad_request", "missing stream_id or head");
+      return;
+    }
+
+    log.info("cascade diff request", {
+      requestId: req.request_id,
+      streamId: req.stream_id,
+      head: req.head,
+      hasBase: Boolean(req.base),
+      filesOnly: req.files_only === true,
+    });
+
+    // Best-effort stream validation. The tracker only carries local-mode
+    // streams; an unknown stream id still resolves fine via git (head/base
+    // are commit hashes), so a missing stream is a warning, not an error.
+    if (tracker && typeof tracker.getStreamBranchName === "function") {
+      try {
+        tracker.getStreamBranchName(req.stream_id);
+      } catch {
+        log.debug("cascade diff: stream not tracked, resolving by commit hash", {
+          streamId: req.stream_id,
+        });
+      }
+    }
+
+    let produced;
+    try {
+      produced = await runGit({
+        repoPath,
+        head: req.head,
+        base: req.base,
+        filePaths: Array.isArray(req.file_paths) ? req.file_paths : undefined,
+        filesOnly: req.files_only === true,
+      });
+    } catch (err) {
+      log.warn("cascade diff: git failed", { requestId: req.request_id, error: err.message });
+      sendError(connection, req.request_id, "internal", `git failed: ${err.message}`);
+      return;
+    }
+
+    try {
+      if (produced.blob.length <= INLINE_THRESHOLD_BYTES) {
+        await connection.sendNotification(RESPONSE_METHOD, {
+          request_id: req.request_id,
+          streaming: false,
+          diff: produced.blob.toString("utf-8"),
+          files_touched: produced.filesTouched,
+          truncated: produced.truncated,
+        });
+        log.info("cascade diff response sent (inline)", {
+          requestId: req.request_id,
+          size: produced.blob.length,
+        });
+        return;
+      }
+      await streamLargeBlob(connection, req.request_id, produced);
+    } catch (err) {
+      log.warn("cascade diff: send failed", { requestId: req.request_id, error: err.message });
+      sendError(connection, req.request_id, "internal", `send failed: ${err.message}`);
+    }
+  };
+
+  connection.onNotification(REQUEST_METHOD, handler);
+  log.info("cascade diff server registered", { repoPath });
+
+  return () => {
+    try {
+      if (typeof connection.offNotification === "function") {
+        connection.offNotification(REQUEST_METHOD, handler);
+      }
+    } catch { /* non-fatal */ }
+  };
+}
+
+// ── Git shell-out ────────────────────────────────────────────────────────────
+
+/**
+ * Resolve a diff via plain git in the repo cwd.
+ *
+ * `head` / `base` are commit hashes — self-identifying, no worktree needed:
+ *   - Single commit (no base): `git show <head>`.
+ *   - Range (base present):    `git diff <base>..<head>`.
+ * `files_only` swaps in `--name-only`. `files_touched` is always computed via
+ * a separate `--name-only` invocation so it is correct even for full diffs.
+ */
+async function runGit({ repoPath, head, base, filePaths, filesOnly }) {
+  const diffArgs = buildGitArgs({ head, base, filePaths, filesOnly });
+  const captured = await spawnCapped(repoPath, diffArgs);
+
+  // files_touched: always compute via --name-only, independent of filesOnly.
+  let filesTouched;
+  if (filesOnly) {
+    filesTouched = parseNameOnly(captured.data);
+  } else {
+    const nameArgs = buildGitArgs({ head, base, filePaths, filesOnly: true });
+    try {
+      const names = await spawnCapped(repoPath, nameArgs);
+      filesTouched = parseNameOnly(names.data);
+    } catch {
+      filesTouched = [];
+    }
+  }
+
+  return {
+    blob: filesOnly ? Buffer.from("") : captured.data,
+    filesTouched,
+    truncated: captured.truncated,
+  };
+}
+
+/** Build the git argv for a diff / name-only request. */
+function buildGitArgs({ head, base, filePaths, filesOnly }) {
+  const paths = Array.isArray(filePaths) && filePaths.length > 0
+    ? ["--", ...filePaths]
+    : [];
+  if (filesOnly) {
+    if (base) {
+      return ["diff", "--name-only", `${base}..${head}`, ...paths];
+    }
+    return ["show", "--name-only", "--format=", head, ...paths];
+  }
+  if (base) {
+    return ["diff", "--no-textconv", "-U3", `${base}..${head}`, ...paths];
+  }
+  return ["show", "--no-textconv", "-U3", "--format=", head, ...paths];
+}
+
+/**
+ * Spawn git, capture stdout up to MAX_DIFF_BYTES. Beyond that, drop the rest
+ * and mark `truncated`. Kills after GIT_TIMEOUT_MS. Resolves on overflow /
+ * timeout; rejects only on spawn error or non-zero exit.
+ */
+function spawnCapped(cwd, args) {
+  return new Promise((resolve, reject) => {
+    let proc;
+    try {
+      proc = spawn("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+    } catch (err) {
+      reject(err);
+      return;
+    }
+
+    const parts = [];
+    let total = 0;
+    let truncated = false;
+    let stderrBuf = "";
+    let settled = false;
+
+    const killTimer = setTimeout(() => {
+      truncated = true;
+      try { proc.kill("SIGKILL"); } catch { /* nothing to kill */ }
+    }, GIT_TIMEOUT_MS);
+
+    proc.stdout.on("data", (chunk) => {
+      if (truncated) return;
+      if (total + chunk.length > MAX_DIFF_BYTES) {
+        const remaining = MAX_DIFF_BYTES - total;
+        if (remaining > 0) parts.push(chunk.subarray(0, remaining));
+        total = MAX_DIFF_BYTES;
+        truncated = true;
+        return;
+      }
+      parts.push(chunk);
+      total += chunk.length;
+    });
+
+    proc.stderr.on("data", (chunk) => {
+      if (stderrBuf.length < 8192) stderrBuf += chunk.toString("utf-8");
+    });
+
+    proc.on("error", (err) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(killTimer);
+      reject(err);
+    });
+
+    proc.on("close", (code) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(killTimer);
+      if (code !== 0 && !truncated) {
+        reject(new Error(`git ${args.join(" ")} exited ${code}: ${stderrBuf.trim().slice(0, 200)}`));
+        return;
+      }
+      resolve({ data: Buffer.concat(parts), truncated });
+    });
+  });
+}
+
+/** Parse `--name-only` output into a deduped list of file paths. */
+function parseNameOnly(buf) {
+  const seen = new Set();
+  for (const line of buf.toString("utf-8").split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed) seen.add(trimmed);
+  }
+  return Array.from(seen);
+}
+
+// ── Streaming ────────────────────────────────────────────────────────────────
+
+/**
+ * Send a large diff as a streaming announcement followed by base64 chunks.
+ * The last chunk carries `final: true` + a sha256 over the full payload.
+ */
+async function streamLargeBlob(connection, requestId, produced) {
+  const { blob, filesTouched, truncated } = produced;
+  // A random nonce keeps two sidecars routing through the same hub from
+  // colliding on the hub-side chunk-stream map even on a retried request_id.
+  const chunkStreamId = `cdiff-${requestId}-${randomBytes(6).toString("hex")}`;
+
+  await connection.sendNotification(RESPONSE_METHOD, {
+    request_id: requestId,
+    streaming: true,
+    chunk_stream_id: chunkStreamId,
+    total_size: blob.length,
+    files_touched: filesTouched,
+  });
+
+  const sha = createHash("sha256").update(blob).digest("hex");
+  const totalChunks = Math.max(1, Math.ceil(blob.length / CHUNK_SIZE_BYTES));
+
+  for (let i = 0; i < totalChunks; i++) {
+    const start = i * CHUNK_SIZE_BYTES;
+    const end = Math.min(start + CHUNK_SIZE_BYTES, blob.length);
+    const slice = blob.subarray(start, end);
+    const isFinal = i === totalChunks - 1;
+    await connection.sendNotification(CHUNK_METHOD, {
+      chunk_stream_id: chunkStreamId,
+      seq: i,
+      data: slice.toString("base64"),
+      ...(isFinal ? { final: true, sha256: sha, truncated } : {}),
+    });
+  }
+
+  log.info("cascade diff response sent (streamed)", {
+    requestId,
+    size: blob.length,
+    chunks: totalChunks,
+  });
+}
+
+/** Reply with the typed error variant of `cascade/diff.response`. Never throws. */
+function sendError(connection, requestId, code, message) {
+  try {
+    Promise.resolve(
+      connection.sendNotification(RESPONSE_METHOD, {
+        request_id: requestId,
+        error: { code, message },
+      }),
+    ).catch((err) => log.warn("cascade diff: error reply failed", { requestId, error: err.message }));
+  } catch (err) {
+    log.warn("cascade diff: error reply threw", { requestId, error: err.message });
+  }
+}

package/src/cascade-events.mjs

@@ -0,0 +1,285 @@
+/**
+ * cascade-events.mjs — x-cascade/* event builders + emit for claude-code-swarm
+ *
+ * cc-swarm emits `x-cascade/*` notifications itself over the MAP connection
+ * (rather than letting git-cascade's `emit` callback drive them). This module
+ * builds the snake_case wire payloads and forwards them as MAP extension
+ * notifications.
+ *
+ * Wire shapes match git-cascade's `events/index.d.ts` (StreamOpenedParams etc.)
+ * so an OpenHive hub can consume them with no translation.
+ */
+
+import { createLogger } from "./log.mjs";
+
+const log = createLogger("cascade-events");
+
+/**
+ * Build the `x-cascade/stream.opened` param shape (snake_case wire format).
+ *
+ * Mirrors git-cascade's `StreamOpenedParams`. Always sets `is_local_mode: true`
+ * — cc-swarm only ever registers existing branches as local-mode streams.
+ *
+ * `parent_stream` carries the fork edge: when the watcher detects a branch
+ * forked from a tracked branch it passes the parent's stream id, and the hub's
+ * `cascade-handler` writes it as `parent_stream_id` so the PR-stack walker can
+ * traverse the stack. Omitted (left undefined) when there is no parent.
+ *
+ * @param {object} opts
+ * @param {string} opts.streamId    git-cascade stream id
+ * @param {string} opts.name        Human-readable stream name
+ * @param {string} opts.agentId     Owning agent id
+ * @param {string} opts.baseCommit  Commit the stream was based from
+ * @param {string} [opts.branchName] Branch the stream maps to
+ * @param {string} [opts.parentStream] Parent stream id, when forked
+ * @param {object} [opts.metadata]  Free-form caller metadata
+ * @returns {object} StreamOpenedParams-shaped object
+ */
+export function buildStreamOpenedParams({ streamId, name, agentId, baseCommit, branchName, parentStream, metadata } = {}) {
+  return {
+    stream_id: streamId,
+    name,
+    agent_id: agentId,
+    base_commit: baseCommit,
+    branch_name: branchName,
+    is_local_mode: true,
+    ...(parentStream ? { parent_stream: parentStream } : {}),
+    metadata: metadata || {},
+  };
+}
+
+/**
+ * Emit an `x-cascade/stream.opened` notification over a MAP connection.
+ *
+ * Fire-and-forget: any failure is caught and logged — this never throws, so a
+ * missing/dead connection can't crash the sidecar.
+ *
+ * @param {object} connection  A MAP AgentConnection (must expose callExtension)
+ * @param {object} params      Payload from buildStreamOpenedParams()
+ */
+export function emitStreamOpened(connection, params) {
+  emitCascadeEvent(connection, "x-cascade/stream.opened", params);
+}
+
+/**
+ * Build the `x-cascade/stream.committed` param shape (snake_case wire format).
+ *
+ * Mirrors git-cascade's `StreamCommittedParams`. The watcher pulls real git
+ * data (summary, files, parent) and a git-cascade change id per commit.
+ *
+ * @param {object} opts
+ * @param {string} opts.streamId        Stream that received the commit
+ * @param {string} opts.commitHash      Commit SHA
+ * @param {string} opts.changeId        git-cascade Change-Id for this change
+ * @param {string} opts.agentId         Authoring agent id ("" when unattributed)
+ * @param {string} opts.messageSummary  First line of the commit message
+ * @param {string[]} opts.filesTouched  Files modified by the commit
+ * @param {string} opts.parentCommit    Parent commit SHA
+ * @param {object} [opts.metadata]      Free-form caller metadata
+ * @returns {object} StreamCommittedParams-shaped object
+ */
+export function buildStreamCommittedParams({ streamId, commitHash, changeId, agentId, messageSummary, filesTouched, parentCommit, metadata } = {}) {
+  return {
+    stream_id: streamId,
+    commit_hash: commitHash,
+    change_id: changeId || "",
+    agent_id: agentId || "",
+    message_summary: messageSummary || "",
+    files_touched: Array.isArray(filesTouched) ? filesTouched : [],
+    parent_commit: parentCommit || "",
+    metadata: metadata || {},
+  };
+}
+
+/**
+ * Emit an `x-cascade/stream.committed` notification over a MAP connection.
+ * Fire-and-forget — never throws.
+ *
+ * @param {object} connection  A MAP AgentConnection (must expose callExtension)
+ * @param {object} params      Payload from buildStreamCommittedParams()
+ */
+export function emitStreamCommitted(connection, params) {
+  emitCascadeEvent(connection, "x-cascade/stream.committed", params);
+}
+
+/**
+ * Build the `x-cascade/stream.merged` param shape (snake_case wire format).
+ *
+ * Mirrors git-cascade's `StreamMergedParams`. `source_stream_id` is best-effort
+ * — the watcher resolves the source branch by the 2nd parent commit and it may
+ * be empty when the source branch was already deleted.
+ *
+ * @param {object} opts
+ * @param {string} opts.sourceStreamId  Stream merged FROM ("" when unresolved)
+ * @param {string} opts.targetStreamId  Stream merged INTO
+ * @param {string} opts.mergeCommit     Resulting merge commit SHA
+ * @param {string} opts.agentId         Agent that performed the merge
+ * @param {string} [opts.sourceCommit]  Head of the source at merge time
+ * @param {string} [opts.strategy]      Merge strategy label
+ * @param {object} [opts.metadata]      Free-form caller metadata
+ * @returns {object} StreamMergedParams-shaped object
+ */
+export function buildStreamMergedParams({ sourceStreamId, targetStreamId, mergeCommit, agentId, sourceCommit, strategy, metadata } = {}) {
+  return {
+    source_stream_id: sourceStreamId || "",
+    target_stream_id: targetStreamId,
+    merge_commit: mergeCommit,
+    agent_id: agentId || "",
+    source_commit: sourceCommit || "",
+    strategy: strategy || "merge-commit",
+    metadata: metadata || {},
+  };
+}
+
+/**
+ * Emit an `x-cascade/stream.merged` notification over a MAP connection.
+ * Fire-and-forget — never throws.
+ *
+ * @param {object} connection  A MAP AgentConnection (must expose callExtension)
+ * @param {object} params      Payload from buildStreamMergedParams()
+ */
+export function emitStreamMerged(connection, params) {
+  emitCascadeEvent(connection, "x-cascade/stream.merged", params);
+}
+
+/**
+ * Build the `x-cascade/stream.pushed` param shape (snake_case wire format).
+ *
+ * Mirrors git-cascade's `StreamPushedParams`.
+ *
+ * @param {object} opts
+ * @param {string} opts.streamId      Stream whose head was pushed
+ * @param {string} opts.agentId       Agent that did the push
+ * @param {string} opts.pushedCommit  Commit SHA at the head when pushed
+ * @param {string} opts.remote        Remote name (e.g. 'origin')
+ * @param {string} opts.remoteRef     Remote ref pushed to
+ * @param {object} [opts.metadata]    Free-form caller metadata
+ * @returns {object} StreamPushedParams-shaped object
+ */
+export function buildStreamPushedParams({ streamId, agentId, pushedCommit, remote, remoteRef, metadata } = {}) {
+  return {
+    stream_id: streamId,
+    agent_id: agentId || "",
+    pushed_commit: pushedCommit,
+    remote: remote || "origin",
+    remote_ref: remoteRef || "",
+    metadata: metadata || {},
+  };
+}
+
+/**
+ * Emit an `x-cascade/stream.pushed` notification over a MAP connection.
+ * Fire-and-forget — never throws.
+ *
+ * @param {object} connection  A MAP AgentConnection (must expose callExtension)
+ * @param {object} params      Payload from buildStreamPushedParams()
+ */
+export function emitStreamPushed(connection, params) {
+  emitCascadeEvent(connection, "x-cascade/stream.pushed", params);
+}
+
+/**
+ * Build the `x-cascade/stream.conflicted` param shape (snake_case wire format).
+ *
+ * Mirrors git-cascade's `StreamConflictedParams`. cc-swarm emits this on the
+ * transition where a tracked stream enters an in-progress merge state (i.e.
+ * the watcher observes `.git/MERGE_HEAD` appear). Rebase conflicts are out of
+ * scope for v1.
+ *
+ * @param {object} opts
+ * @param {string} opts.streamId          Stream that became conflicted
+ * @param {string} [opts.conflictId]      Persisted conflict record id (cf-xxx)
+ * @param {string[]} opts.conflictedFiles Files reported as conflicted
+ * @param {string} [opts.agentId]         Agent that triggered the conflicting op
+ * @param {string} [opts.conflictingCommit] Commit being applied (e.g. MERGE_HEAD)
+ * @param {string} [opts.targetCommit]    Commit being applied onto (HEAD)
+ * @param {string} [opts.source]          Operation flavor: "merge" | "rebase" | ...
+ * @param {object} [opts.metadata]        Free-form caller metadata
+ * @returns {object} StreamConflictedParams-shaped object
+ */
+export function buildStreamConflictedParams({ streamId, conflictId, conflictedFiles, agentId, conflictingCommit, targetCommit, source, metadata } = {}) {
+  return {
+    stream_id: streamId,
+    ...(conflictId ? { conflict_id: conflictId } : {}),
+    conflicted_files: Array.isArray(conflictedFiles) ? conflictedFiles : [],
+    agent_id: agentId || "",
+    conflicting_commit: conflictingCommit || "",
+    target_commit: targetCommit || "",
+    source: source || "merge",
+    metadata: metadata || {},
+  };
+}
+
+/**
+ * Emit an `x-cascade/stream.conflicted` notification over a MAP connection.
+ * Fire-and-forget — never throws.
+ *
+ * @param {object} connection  A MAP AgentConnection (must expose callExtension)
+ * @param {object} params      Payload from buildStreamConflictedParams()
+ */
+export function emitStreamConflicted(connection, params) {
+  emitCascadeEvent(connection, "x-cascade/stream.conflicted", params);
+}
+
+/**
+ * Build the `x-cascade/stream.conflict_resolved` param shape (snake_case wire).
+ *
+ * Mirrors git-cascade's `StreamConflictResolvedParams`. cc-swarm emits this on
+ * the transition where the in-progress merge state goes away: either HEAD
+ * advanced to a merge commit (`manual` / `agent` resolution) or HEAD is
+ * unchanged (the merge was aborted — `abandoned`).
+ *
+ * @param {object} opts
+ * @param {string} opts.streamId          Stream whose conflict was resolved
+ * @param {string} opts.conflictId        Conflict record id that was resolved
+ * @param {string} opts.resolutionMethod  "manual" | "agent" | "abandoned" | ...
+ * @param {string} [opts.resolvedBy]      Agent or human that resolved it
+ * @param {string} [opts.resolutionSummary] Optional human-readable summary
+ * @param {object} [opts.metadata]        Free-form caller metadata
+ * @returns {object} StreamConflictResolvedParams-shaped object
+ */
+export function buildStreamConflictResolvedParams({ streamId, conflictId, resolutionMethod, resolvedBy, resolutionSummary, metadata } = {}) {
+  return {
+    stream_id: streamId,
+    conflict_id: conflictId || "",
+    resolution_method: resolutionMethod || "manual",
+    ...(resolvedBy ? { resolved_by: resolvedBy } : {}),
+    ...(resolutionSummary ? { resolution_summary: resolutionSummary } : {}),
+    metadata: metadata || {},
+  };
+}
+
+/**
+ * Emit an `x-cascade/stream.conflict_resolved` notification over a MAP connection.
+ * Fire-and-forget — never throws.
+ *
+ * @param {object} connection  A MAP AgentConnection (must expose callExtension)
+ * @param {object} params      Payload from buildStreamConflictResolvedParams()
+ */
+export function emitStreamConflictResolved(connection, params) {
+  emitCascadeEvent(connection, "x-cascade/stream.conflict_resolved", params);
+}
+
+/**
+ * Shared fire-and-forget emit for all `x-cascade/*` notifications.
+ *
+ * Any failure (no connection, callExtension throws, promise rejects) is caught
+ * and logged. This never throws — a missing/dead connection or a misbehaving
+ * hub can't crash the sidecar.
+ *
+ * @param {object} connection  A MAP AgentConnection (must expose callExtension)
+ * @param {string} method      Full `x-cascade/*` method name
+ * @param {object} params      Snake_case wire payload
+ */
+function emitCascadeEvent(connection, method, params) {
+  if (!connection || typeof connection.callExtension !== "function") {
+    log.debug("skipping cascade emit: no MAP connection", { method });
+    return;
+  }
+  try {
+    Promise.resolve(connection.callExtension(method, params))
+      .catch((err) => log.warn("cascade emit failed", { method, error: err.message }));
+  } catch (err) {
+    log.warn("cascade emit threw", { method, error: err.message });
+  }
+}