mixdog 1.2.3 → 1.2.5

package/src/tui/session/worktree-setup-notice.mjs

@@ -0,0 +1,38 @@
+/**
+ * src/tui/session/worktree-setup-notice.mjs - the one-line transcript notice
+ * shown while a new worktree's dependencies install (runtime.onWorktreeSetup).
+ * Only runs that install anything reach it; one notice per run, patched in
+ * place, so every surface showing the transcript (TUI, desktop, remote) sees
+ * the same line. The details (output, failures, skips) go to the agent only.
+ */
+const ENDINGS = {
+  completed: 'Worktree dependencies installed.',
+  cancelled: 'Installing worktree dependencies was cancelled.',
+};
+const INCOMPLETE = 'Some worktree dependencies were not installed; the agent has the details.';
+
+/** Notice text and tone for one install progress event. */
+export function worktreeSetupNotice(event) {
+  if (event.final) {
+    const text = ENDINGS[event.status] ?? INCOMPLETE;
+    return { text, tone: event.status === 'completed' ? 'info' : 'warn' };
+  }
+  const what = event.label || event.command;
+  return { text: `Installing worktree dependencies [${event.index + 1}/${event.total}]: ${what}`, tone: 'info' };
+}
+
+export function createWorktreeSetupNotices({ pushItem, patchItem, nextId }) {
+  const items = new Map();
+  return (event) => {
+    const notice = worktreeSetupNotice(event);
+    const itemId = items.get(event.id);
+    if (itemId === undefined) {
+      const id = nextId();
+      items.set(event.id, id);
+      pushItem({ kind: 'notice', id, ...notice });
+    } else {
+      patchItem(itemId, notice);
+    }
+    if (event.final) items.delete(event.id);
+  };
+}

package/src/tui/spinner-meta.mjs

@@ -9,6 +9,8 @@
  * for 30s. One builder, one answer.
  */
 
+import { quietProgressLabel, quietProgressParts } from '../runtime/shared/quiet-progress.mjs';
+
 const compactNumberFormatter = new Intl.NumberFormat('en-US', {
   notation: 'compact',
   maximumFractionDigits: 1,
@@ -67,9 +69,13 @@ export function buildSpinnerMeta({
   thinkingSince = 0,
   thinkingMs = 0,
   effort = '',
+  // The turn's published quiet state (`spinner.quiet`) and the clock it is read at.
+  quiet = null,
+  now = Date.now(),
   verbose: _verbose = false,
 } = {}) {
   const tokens = Math.max(0, Number(outputTokens) || 0);
+  const quietParts = quietProgressParts(quiet, now, quiet?.warnMs);
   const thinkingParts = spinnerThinkingParts({ thinking, thinkingSince, thinkingMs, effort });
   const thinkingText = spinnerThinkingLabel({ thinking, thinkingSince, thinkingMs, effort });
   return {
@@ -83,6 +89,10 @@ export function buildSpinnerMeta({
     showTokens: tokens > 0,
     thinkingText,
     thinkingActive: Boolean(thinking || Number(thinkingSince) > 0),
+    // Quiet-time cue: structured for the desktop's i18n, English for the TUI;
+    // `escalated` once the silence reaches the stall watchdog's warn point.
+    quietParts,
+    quietText: quietProgressLabel(quietParts),
   };
 }
 

package/src/tui/spinner-verbs.mjs

@@ -247,6 +247,9 @@ export const SPINNER_MODE_OVERRIDE_VERBS = {
   'auto-clear': 'Auto-clearing conversation',
   resuming: 'Resuming conversation',
   'task-wait': '작업 대기 중',
+  // The request is sent and its response headers are pending: the model is
+  // queued or thinking server-side.
+  'model-thinking': 'Model thinking',
 };
 
 /**

package/src/ui/statusline.mjs

@@ -31,7 +31,11 @@ import {
   num,
   formatElapsed,
 } from '../runtime/shared/statusline/statusline-format.mjs';
-import { shellJobsStatus, memoryCycleStatus } from '../runtime/shared/statusline/statusline-segments.mjs';
+import {
+  shellJobsStatus,
+  memoryCycleStatus,
+  unconfirmedShellCount,
+} from '../runtime/shared/statusline/statusline-segments.mjs';
 import {
   agentStatuslinePayload,
   classifyAgentWorkers,
@@ -397,10 +401,16 @@ function activitySegments({ sessionId, clientHostPid, agentWorkers, agentJobs, a
     const n = runningWorkers.length;
     segment(`Running ${n} Agent${n === 1 ? '' : 's'}`, agentsElapsed(runningWorkers));
   }
-  if (shellStatus.count > 0) {
-    const n = shellStatus.count;
+  const unconfirmed = unconfirmedShellCount(shellStatus);
+  if (shellStatus.count - unconfirmed > 0) {
+    const n = shellStatus.count - unconfirmed;
     segment(`Running ${n} Shell${n === 1 ? '' : 's'}`, shellStatus.elapsedLabel);
   }
+  if (unconfirmed > 0) {
+    parts.push(
+      `${YLW}⚠ ${unconfirmed} Shell${unconfirmed === 1 ? '' : 's'} termination unconfirmed${R} ${D}·${R} /shells`
+    );
+  }
   const webSearch = webSearchActivity(activeTools, { sessionId, clientHostPid });
   if (webSearch.count > 0) segment('Web Searching', webSearch.elapsed);
   // Memory cycle segment — single unified "Memory" wording for all states:

package/src/ui/streaming-markdown-heal.mjs

@@ -8,19 +8,47 @@ const HEALABLE_MARKDOWN_SYNTAX = /[`*_~[]/;
 function openFence(text) {
   let marker = '';
   let length = 0;
+  let start = 0;
+  let lineStart = 0;
   for (const rawLine of String(text ?? '').split('\n')) {
     const fence = FENCE_LINE.exec(rawLine.replace(/\r$/, ''));
-    if (!fence) continue;
-    const marks = fence[1];
-    if (!marker) {
-      marker = marks[0];
-      length = marks.length;
-    } else if (marks[0] === marker && marks.length >= length && !fence[2].trim()) {
-      marker = '';
-      length = 0;
+    if (fence) {
+      const marks = fence[1];
+      if (!marker) {
+        marker = marks[0];
+        length = marks.length;
+        start = lineStart;
+      } else if (marks[0] === marker && marks.length >= length && !fence[2].trim()) {
+        marker = '';
+        length = 0;
+      }
     }
+    lineStart += rawLine.length + 1;
   }
-  return marker ? { marker, length } : null;
+  return marker ? { marker, length, start } : null;
+}
+
+// The opening fence line arrives a token at a time: ``` → ```py → ```python.
+// Rendered at once, the card opened unlabelled and then relabelled (and
+// re-highlighted) per token. The card appears with its first code character:
+// an opening line alone would paint an empty box before any code.
+function trimPartialOpeningFence(text, fence) {
+  const lineEnd = text.indexOf('\n', fence.start);
+  return lineEnd >= 0 && /\S/.test(text.slice(lineEnd + 1)) ? text : text.slice(0, fence.start);
+}
+
+// A line holding only a block marker so far has no content to show, and the
+// marker alone parses as something else: `-` or `=` under a paragraph is a
+// setext underline (the paragraph flashed into a heading until the item text
+// arrived), `2` is a lazy paragraph continuation until its `.` arrives, `#`
+// grows into `##`, and a lone backtick run is literal text until it becomes a
+// fence. Hold the line back until its first content character.
+const PENDING_BLOCK_MARKER_LINE = /(?:^|\n)[ \t]*(?:[-+*=_#>~`]+|\d{1,9}[.)]?)[ \t]*$/;
+
+function trimPendingBlockMarker(text) {
+  const pending = PENDING_BLOCK_MARKER_LINE.exec(text);
+  if (!pending) return text;
+  return text.slice(0, pending.index + (pending[0].startsWith('\n') ? 1 : 0));
 }
 
 // A closing fence arrives a token at a time. Until its run is long enough to
@@ -57,7 +85,9 @@ function closeInlineCode(text, isPendingLocalPath) {
     } else if (run === open) open = 0;
     index = end;
   }
-  if (open && isPendingLocalPath?.(text.slice(openIndex + open))) {
+  // An opener with nothing after it yet closes into an empty span, which
+  // parses as a literal backtick run that then vanishes into code.
+  if (open && (!text.slice(openIndex + open) || isPendingLocalPath?.(text.slice(openIndex + open)))) {
     return text.slice(0, openIndex);
   }
   return open > 0 ? `${text}${'`'.repeat(open)}` : text;
@@ -93,6 +123,7 @@ function scanEmphasisRuns(masked) {
     let end = index + 1;
     while (masked[end] === marker) end += 1;
     const length = end - index;
+    const at = index;
     const before = index > 0 ? masked[index - 1] : '';
     const after = end < masked.length ? masked[end] : '';
     const beforeSpace = isMarkdownSpace(before);
@@ -102,16 +133,26 @@ function scanEmphasisRuns(masked) {
     const left = !afterSpace && (!afterPunctuation || beforeSpace || beforePunctuation);
     const right = !beforeSpace && (!beforePunctuation || afterSpace || afterPunctuation);
     if (marker === '~') {
-      if (length >= 2) runs.push({ marker, length: 2, canOpen: left, canClose: right });
+      // A single tilde is inert, but at the end it may be half of `~~`.
+      runs.push({
+        marker,
+        length: Math.min(length, 2),
+        canOpen: left && length >= 2,
+        canClose: right && length >= 2,
+        at,
+        end,
+      });
     } else if (marker === '_') {
       runs.push({
         marker,
         length,
         canOpen: left && (!right || beforePunctuation),
         canClose: right && (!left || afterPunctuation),
+        at,
+        end,
       });
     } else {
-      runs.push({ marker, length, canOpen: left, canClose: right });
+      runs.push({ marker, length, canOpen: left, canClose: right, at, end });
     }
     index = end;
   }
@@ -120,7 +161,9 @@ function scanEmphasisRuns(masked) {
 
 function closeEmphasis(text) {
   const open = [];
-  for (const run of scanEmphasisRuns(maskCode(text))) {
+  const runs = scanEmphasisRuns(maskCode(text));
+  const last = runs[runs.length - 1];
+  for (const run of runs) {
     let length = run.length;
     while (run.canClose && length > 0) {
       let match = -1;
@@ -137,13 +180,21 @@ function closeEmphasis(text) {
       length -= used;
       open.length = opener.length > 0 ? match + 1 : match;
     }
+    // A run ending the text that closed nothing has no content after it yet:
+    // it painted as literal `**` until the next token turned it into style.
+    if (run === last && run.end === text.length && length === run.length) {
+      return closeEmphasis(text.slice(0, run.at));
+    }
     if (length > 0 && run.canOpen) open.push({ marker: run.marker, length });
   }
-  let healed = text;
+  // Closers go before trailing whitespace: `**word ` closed after the space
+  // could not close (a closing run must follow non-space) and stayed literal.
+  const body = text.trimEnd();
+  let closers = '';
   for (let index = open.length - 1; index >= 0; index -= 1) {
-    healed += open[index].marker.repeat(Math.min(open[index].length, 3));
+    closers += open[index].marker.repeat(Math.min(open[index].length, 3));
   }
-  return healed;
+  return closers ? `${body}${closers}${text.slice(body.length)}` : text;
 }
 
 function linkDestinationEnd(text, start) {
@@ -246,8 +297,9 @@ function trimPendingTableHead(text) {
 export function healStreamingMarkdownTail(text, isPendingLocalPath) {
   const source = String(text ?? '');
   const fence = source.includes('`') || source.includes('~') ? openFence(source) : null;
-  if (fence) return trimPartialClosingFence(source, fence);
-  const value = source.includes('|') ? trimPendingTableHead(source) : source;
+  if (fence) return trimPartialOpeningFence(trimPartialClosingFence(source, fence), fence);
+  const unmarked = trimPendingBlockMarker(source);
+  const value = unmarked.includes('|') ? trimPendingTableHead(unmarked) : unmarked;
   const hasSyntax = HEALABLE_MARKDOWN_SYNTAX.test(value);
   if (!value || (!hasSyntax && !isPendingLocalPath)) return value;
   const healed = hasSyntax

package/src/runtime/agent/orchestrator/providers/model-pricing-rates.mjs

@@ -1 +0,0 @@
-export * from '../../../shared/llm/model-pricing-rates.mjs';

package/src/runtime/agent/orchestrator/session/manager/foreign-pending-messages.mjs

@@ -1,346 +0,0 @@
-import { stat } from 'node:fs/promises';
-import { isProcessAlive } from '../store/paths-heartbeat.mjs';
-import {
-  isCompletionNotificationEntry,
-  isStaleUserInjection,
-  lateDeliveryText,
-  normalizePendingMessageEntry,
-  pendingMessageId,
-  pendingMessageText,
-} from './pending-message-entry.mjs';
-import { isInternalRuntimeNotificationText } from './prompt-utils.mjs';
-import { lifecycleTokenClosed } from './pending-lifecycle-epoch.mjs';
-
-const HANDOFF_RETRY_MS = 1000;
-const HANDOFF_RELEASE_SLACK_MS = 50;
-
-/**
- * One session's spool queue, split into what this process takes and what stays
- * on disk. A foreign user message is taken (and parked with a handoff stamp
- * until the consumer owns a copy); an entry already handed off stays until its
- * release window expires or its owner is gone; everything else is kept.
- *
- * Appends to `request.taken` / `request.released`, tightens
- * `request.rescanDueAt` to the earliest live handoff deadline, and returns the
- * entries the queue keeps.
- */
-function takeForeignMessagesFromQueue(queue, request, handoffReleaseMs) {
-  const now = Date.now();
-  const kept = [];
-  for (const entry of queue) {
-    const id = pendingMessageId(entry);
-    const handoffAt = Number(entry?.handoffAt) || 0;
-    const handoffPid = Number(entry?.handoffPid) || 0;
-    if (handoffAt > 0) {
-      const dueAt = handoffAt + handoffReleaseMs;
-      const expired = now >= dueAt;
-      if (!expired) {
-        request.rescanDueAt = request.rescanDueAt === 0 ? dueAt : Math.min(request.rescanDueAt, dueAt);
-      }
-      if (handoffPid === process.pid) {
-        if (expired) {
-          if (id) request.released.push(id);
-          continue;
-        }
-        kept.push(entry);
-        continue;
-      }
-      if (!expired || isProcessAlive(handoffPid)) {
-        kept.push(entry);
-        continue;
-      }
-    }
-    const text = pendingMessageText(entry);
-    const foreignUser =
-      id &&
-      !request.localIds.has(id) &&
-      !isCompletionNotificationEntry(entry) &&
-      text &&
-      !isInternalRuntimeNotificationText(text);
-    if (!foreignUser) {
-      kept.push(entry);
-      continue;
-    }
-    const normalized = normalizePendingMessageEntry(entry);
-    const structured = Array.isArray(normalized?.content) || Boolean(normalized?.options);
-    let takenText = text;
-    let content = normalized?.content ?? text;
-    if (isStaleUserInjection(entry)) {
-      takenText = lateDeliveryText(text, entry);
-      content = Array.isArray(normalized?.content)
-        ? [{ type: 'text', text: takenText.slice(0, takenText.length - text.length) }, ...normalized.content]
-        : takenText;
-    }
-    request.taken.push({
-      ...(structured ? { content } : {}),
-      text: takenText,
-      id,
-      ...(normalized?.options ? { options: normalized.options } : {}),
-    });
-    // Park rather than delete until the consumer owns a copy.
-    kept.push({ ...entry, handoffAt: now, handoffPid: process.pid });
-  }
-  return kept;
-}
-
-/**
- * Owns cross-process pending-message polling and the durable two-phase handoff.
- * Queue storage and lifecycle authority stay in the parent pending-message
- * service and are supplied as narrow callbacks.
- */
-export class ForeignPendingMessageController {
-  constructor(dependencies) {
-    this._dependencies = dependencies;
-    this._scanLimit = Math.max(128, Number(process.env.MIXDOG_FOREIGN_SPOOL_SCAN_LIMIT) || 512);
-    this._handoffReleaseMs = Math.max(1000, Number(process.env.MIXDOG_FOREIGN_HANDOFF_RELEASE_MS) || 10000);
-    this._releaseTimers = new Map();
-    this._drainRequests = new Map();
-    this._scanMemo = new Map();
-    this._drainScheduled = false;
-    this._drainRunning = false;
-  }
-
-  cancelHandoffRelease(sessionId) {
-    const existing = this._releaseTimers.get(sessionId);
-    if (existing) {
-      try {
-        clearTimeout(existing.timer);
-      } catch {
-        /* best-effort */
-      }
-    }
-    this._releaseTimers.delete(sessionId);
-  }
-
-  async drainUserInjections(sessionId) {
-    const { currentLifecycleToken, isValidSessionId } = this._dependencies;
-    if (!isValidSessionId(sessionId)) return [];
-    // One durable read decides both the epoch and the tombstone refusal.
-    const epochToken = currentLifecycleToken(sessionId);
-    if (lifecycleTokenClosed(epochToken)) return [];
-    return new Promise((resolve) => {
-      const existing = this._drainRequests.get(sessionId);
-      if (existing && existing.epochToken === epochToken) {
-        existing.waiters.push(resolve);
-      } else {
-        if (existing) this._settleDrain(existing, []);
-        this._drainRequests.set(sessionId, {
-          sessionId,
-          epochToken,
-          waiters: [resolve],
-          localIds: null,
-          taken: [],
-          released: [],
-          rescanDueAt: 0,
-          lifecycleDecided: false,
-        });
-      }
-      this._scheduleDrainBatch();
-    });
-  }
-
-  _scheduleHandoffRelease(sessionId, delayMs = this._handoffReleaseMs) {
-    const { isValidSessionId } = this._dependencies;
-    if (!isValidSessionId(sessionId)) return;
-    const delay = Math.max(1, Number(delayMs) || 0);
-    const dueAt = Date.now() + delay;
-    const existing = this._releaseTimers.get(sessionId);
-    if (existing) {
-      if (existing.dueAt <= dueAt) return;
-      try {
-        clearTimeout(existing.timer);
-      } catch {
-        /* best-effort */
-      }
-    }
-    const timer = setTimeout(() => {
-      this._releaseTimers.delete(sessionId);
-      void this._releaseExpiredHandoffs(sessionId);
-    }, delay);
-    // The row is durable; cleanup must not keep a shutting-down process open.
-    try {
-      timer.unref?.();
-    } catch {
-      /* ignore */
-    }
-    this._releaseTimers.set(sessionId, { timer, dueAt });
-  }
-
-  _releaseExpiredHandoffs(sessionId) {
-    const {
-      chainSpoolTail,
-      currentLifecycleToken,
-      getSpoolTail,
-      isValidSessionId,
-      lifecycleEpochMoved,
-      normalizeStore,
-      removeInDeliveryIds,
-      setSpoolQueue,
-      updateSpool,
-      warn,
-    } = this._dependencies;
-    if (!isValidSessionId(sessionId)) return Promise.resolve(0);
-    const epochToken = currentLifecycleToken(sessionId);
-    const released = [];
-    let nextDueIn = 0;
-    const preceding = getSpoolTail(sessionId) || Promise.resolve();
-    const operation = preceding
-      .catch(() => {})
-      .then(() =>
-        updateSpool(sessionId, (raw) => {
-          released.length = 0;
-          nextDueIn = 0;
-          // A generation move transfers ownership; never clean the new queue.
-          if (lifecycleEpochMoved(sessionId, epochToken)) return undefined;
-          const next = normalizeStore(raw);
-          const queue = Array.isArray(next.sessions[sessionId]) ? next.sessions[sessionId] : [];
-          if (queue.length === 0) return undefined;
-          const now = Date.now();
-          const kept = [];
-          for (const entry of queue) {
-            const handoffAt = Number(entry?.handoffAt) || 0;
-            const handoffPid = Number(entry?.handoffPid) || 0;
-            if (handoffAt > 0 && handoffPid === process.pid) {
-              const remaining = this._handoffReleaseMs - (now - handoffAt);
-              if (remaining <= 0) {
-                const id = pendingMessageId(entry);
-                if (id) released.push(id);
-                continue;
-              }
-              nextDueIn = nextDueIn === 0 ? remaining : Math.min(nextDueIn, remaining);
-            }
-            kept.push(entry);
-          }
-          if (released.length === 0) return undefined;
-          setSpoolQueue(next, sessionId, kept);
-          next.updatedAt = now;
-          return next;
-        })
-      )
-      .then(() => {
-        if (released.length > 0) removeInDeliveryIds(sessionId, released);
-        if (nextDueIn > 0) {
-          this._scheduleHandoffRelease(sessionId, nextDueIn + HANDOFF_RELEASE_SLACK_MS);
-        }
-        return released.length;
-      })
-      .catch((err) => {
-        warn(`[session] foreign-injection handoff release failed sessionId=${sessionId}: ${err?.message || err}\n`);
-        // The rows remain durable, so contention and I/O failures retry.
-        this._scheduleHandoffRelease(sessionId, HANDOFF_RETRY_MS);
-        return 0;
-      });
-    return chainSpoolTail(sessionId, operation);
-  }
-
-  _rememberScan(sessionId, mtime, rescanDueAt) {
-    this._scanMemo.delete(sessionId);
-    this._scanMemo.set(sessionId, { mtime, rescanDueAt: Number(rescanDueAt) || 0 });
-    while (this._scanMemo.size > this._scanLimit) {
-      const oldest = this._scanMemo.keys().next().value;
-      if (oldest === undefined) break;
-      this._scanMemo.delete(oldest);
-    }
-  }
-
-  _scanNeeded(sessionId, mtime, now) {
-    const memo = this._scanMemo.get(sessionId);
-    if (!memo || memo.mtime !== mtime) return true;
-    return memo.rescanDueAt > 0 && now >= memo.rescanDueAt;
-  }
-
-  _settleDrain(request, value) {
-    for (const resolve of request.waiters) {
-      try {
-        resolve(value);
-      } catch {
-        /* a consumer cannot break the batch */
-      }
-    }
-  }
-
-  _scheduleDrainBatch() {
-    if (this._drainScheduled || this._drainRunning || this._drainRequests.size === 0) return;
-    this._drainScheduled = true;
-    setImmediate(() => {
-      this._drainScheduled = false;
-      void this._flushDrainBatch();
-    });
-  }
-
-  async _flushDrainBatch() {
-    if (this._drainRunning) return;
-    this._drainRunning = true;
-    const batch = [...this._drainRequests.values()];
-    this._drainRequests.clear();
-    try {
-      // Each session drains against its own shard and lock, so one busy
-      // session never delays (or fails) another's intake.
-      await Promise.all(batch.map((request) => this._drainOne(request)));
-    } finally {
-      this._drainRunning = false;
-      this._scheduleDrainBatch();
-    }
-  }
-
-  async _drainOne(request) {
-    const {
-      addInDeliveryIds,
-      lifecycleInvalidated,
-      localIds,
-      normalizeStore,
-      removeInDeliveryIds,
-      setSpoolQueue,
-      spoolPath,
-      updateSpool,
-      warn,
-    } = this._dependencies;
-    const { sessionId, epochToken } = request;
-    try {
-      let mtime = 0;
-      try {
-        mtime = (await stat(spoolPath(sessionId))).mtimeMs || 0;
-      } catch {
-        this._settleDrain(request, []);
-        return;
-      }
-      if (!this._scanNeeded(sessionId, mtime, Date.now()) || lifecycleInvalidated(sessionId, epochToken)) {
-        this._settleDrain(request, []);
-        return;
-      }
-      request.localIds = localIds(sessionId);
-      request.taken = [];
-      request.released = [];
-      request.rescanDueAt = 0;
-      request.lifecycleDecided = false;
-      await updateSpool(
-        sessionId,
-        (raw) => {
-          const next = normalizeStore(raw);
-          if (lifecycleInvalidated(sessionId, epochToken)) return undefined;
-          request.lifecycleDecided = true;
-          const queue = Array.isArray(next.sessions[sessionId]) ? next.sessions[sessionId] : [];
-          if (queue.length === 0) return undefined;
-          const kept = takeForeignMessagesFromQueue(queue, request, this._handoffReleaseMs);
-          if (request.taken.length === 0 && request.released.length === 0) return undefined;
-          setSpoolQueue(next, sessionId, kept);
-          next.updatedAt = Date.now();
-          return next;
-        },
-        { timeoutMs: 0 }
-      );
-      if (request.lifecycleDecided) this._rememberScan(sessionId, mtime, request.rescanDueAt);
-      if (request.taken.length > 0) {
-        addInDeliveryIds(sessionId, request.taken.map((item) => item?.id).filter(Boolean));
-        this._scheduleHandoffRelease(sessionId, this._handoffReleaseMs + HANDOFF_RELEASE_SLACK_MS);
-      }
-      if (request.released.length > 0) removeInDeliveryIds(sessionId, request.released);
-      this._settleDrain(request, request.taken);
-    } catch (err) {
-      if (err?.code !== 'ELOCKCONTENDED') {
-        warn(`[session] foreign-injection drain failed: ${err?.message || err}\n`);
-      }
-      this._settleDrain(request, []);
-    }
-  }
-}