mixdog 0.9.18 → 0.9.19

package/src/runtime/agent/orchestrator/tools/builtin/search-tool.mjs

@@ -53,6 +53,7 @@ import {
     normalizeGrepLine,
     splitGrepCountPrefix,
     splitGrepLinePrefix,
+    splitGrepLineNumberOnlyPrefix,
 } from './grep-formatting.mjs';
 import {
     cacheGet,
@@ -66,6 +67,8 @@ import { applyGrepContextLeadPolicy, GREP_CONTEXT_MAX, hasUnsupportedRipgrepRege
 // Default surrounding-lines window applied by output_mode:'content_with_context'
 // when the caller does not pass an explicit -A/-B/-C/context. Sized to cover a
 // typical function/block so a match arrives readable without a follow-up read.
+// Explicit -A/-B/-C is honored up to the generic GREP_CONTEXT_MAX (no tighter
+// context-mode clamp by policy); only head_limit blocks are context-clamped.
 const GREP_AUTO_CONTEXT_LINES = 25;
 
 const MIXDOG_GREP_CASE_HINT_PROBE = /^(1|true|yes|on)$/i.test(String(process.env.MIXDOG_GREP_CASE_HINT_PROBE || ''));
@@ -361,12 +364,116 @@ function buildGrepChunkMergePrefix(patternChunkCount, truncated, aggregateBudget
     return `[${parts.join('; ')}]\n`;
 }
 
+// --- context-mode match-block windowing (Parts 2 & 3) ---------------------
+// In context mode (explicit -A/-B/-C or content_with_context auto), head_limit
+// and offset count MATCH BLOCKS, not raw output lines, and truncation keeps a
+// head+tail slice with a middle marker instead of dropping the tail.
+function grepBlockMatchAnchor(line, filenameOmitted) {
+    if (filenameOmitted) {
+        const p = splitGrepLineNumberOnlyPrefix(line);
+        return p && p.delimiter === ':' ? `#${p.lineNo}` : '';
+    }
+    const s = splitGrepLinePrefix(line);
+    return s && s.delimiter === ':' ? `${s.path}\0${s.lineNo}` : '';
+}
+
+function parseGrepContextBlocks(lines, filenameOmitted) {
+    const blocks = [];
+    let pending = [];
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        if (line === '--') { pending = []; i++; continue; }
+        const anchor = grepBlockMatchAnchor(line, filenameOmitted);
+        if (anchor) {
+            const blockLines = pending.concat([line]);
+            pending = [];
+            i++;
+            while (i < lines.length) {
+                const next = lines[i];
+                if (next === '--' || grepBlockMatchAnchor(next, filenameOmitted)) break;
+                blockLines.push(next);
+                i++;
+            }
+            blocks.push({ anchor, lines: blockLines });
+            continue;
+        }
+        pending.push(line);
+        i++;
+    }
+    return blocks;
+}
+
+function formatGrepContextOutput({ allLines, workDir, outputMode, filenameOmitted, headLimit, offset, totalKnown = true }) {
+    const norm = allLines.map((l) => (l === '--' ? '--' : relativeGrepLine(l, workDir, false, outputMode, filenameOmitted)));
+    const blocks = parseGrepContextBlocks(norm, filenameOmitted);
+    const total = blocks.length;
+    if (total === 0) return { text: '', total: 0, shown: 0, omitted: 0 };
+    // Finding 2/3: denominator is the PRE-offset grand total; on a partial rg
+    // read (stdout cap / stream cap) it is a lower bound, so print ">=T".
+    const totalStr = totalKnown ? `${total}` : `>=${total}`;
+    const afterOffset = offset > 0 ? blocks.slice(offset) : blocks;
+    if (afterOffset.length === 0) {
+        // On a partial stream (line cap / timeout) the parsed blocks are a
+        // lower bound — an offset beyond them is NOT proven past the last
+        // match, so steer toward narrowing instead of claiming "past end".
+        const text = totalKnown
+            ? `[Showing 0 of ${totalStr} matches; offset ${offset} past end]`
+            : `[Showing 0 of ${totalStr} matches (results partial); offset ${offset} is beyond the streamed window — matches past it may exist. Narrow path/glob/pattern instead of paging deeper.]`;
+        return { text, total, shown: 0, omitted: 0 };
+    }
+    const shown = headLimit === Infinity ? afterOffset.length : Math.min(headLimit, afterOffset.length);
+    const omitted = afterOffset.length - shown;
+    const render = (arr) => arr.map((b) => b.lines.join('\n'));
+    let segments;
+    let nextOffset = offset + shown;
+    if (omitted > 0 && shown > 0) {
+        // Keep head + tail so both ends of the match range stay visible.
+        const headCount = Math.max(1, Math.ceil(shown / 2));
+        const tailCount = shown - headCount;
+        const head = render(afterOffset.slice(0, headCount));
+        const tail = tailCount > 0 ? render(afterOffset.slice(afterOffset.length - tailCount)) : [];
+        segments = [...head, `…${omitted} matches omitted…`, ...tail];
+        // Paging must resume at the first OMITTED block (right after the head
+        // slice): offset+shown would permanently skip the middle blocks that
+        // the tail slice displaced. Tail blocks re-appear on later pages —
+        // duplication is acceptable, silent loss is not.
+        nextOffset = offset + headCount;
+    } else {
+        segments = render(afterOffset.slice(0, shown));
+    }
+    const notice = (omitted > 0 || !totalKnown)
+        ? `\n[Showing ${shown} of ${totalStr} matches${totalKnown ? '' : ' (results partial)'}; pass offset:${nextOffset} for more]`
+        : '';
+    return { text: segments.join('\n--\n') + notice, total, shown, omitted };
+}
+
+// Part 1: drop path:line match lines already emitted by an earlier pattern in
+// a pattern[] fan-out. Context ('-') lines and non-match lines pass through.
+function dedupeFanoutMatchLines(body, seen) {
+    const text = String(body);
+    if (/^Error:/.test(text)) return text;
+    const out = [];
+    for (const line of text.split('\n')) {
+        const s = splitGrepLinePrefix(line);
+        if (s && s.delimiter === ':') {
+            const key = `${s.path}\0${s.lineNo}`;
+            if (seen.has(key)) continue;
+            seen.add(key);
+        }
+        out.push(line);
+    }
+    return out.join('\n');
+}
+
 function formatGrepOutput({ windowed, totalWindowed, totalKnown, headLimit, offset, outputMode, patterns: _patterns, beforeN, afterN, contextN, searchPath, grepResolvedPath: _grepResolvedPath, workDir, globPatterns: _globPatterns, fileType: _fileType, filenameOmitted = false, prefix = '', broadAdvisory: _broadAdvisory = true, disableContentGrouping = false }) {
     const lines = headLimit === Infinity ? windowed : windowed.slice(0, headLimit);
     const normalized = lines.map((line) => relativeGrepLine(line, workDir, outputMode === 'files_with_matches', outputMode, filenameOmitted));
     const remaining = Math.max(0, totalWindowed - lines.length);
     const shown = lines.length;
-    const total = totalWindowed;
+    // Finding 3: PRE-offset grand total so the denominator matches the
+    // context-mode notice (offset==0 leaves this unchanged).
+    const total = offset + totalWindowed;
     const scopePath = JSON.stringify(normalizeOutputPath(searchPath));
     const truncated = (remaining > 0 || !totalKnown)
         ? (totalKnown
@@ -604,6 +711,33 @@ export async function executeGrepTool(args, workDir, executeChildBuiltinTool, re
     if (fileTypes.length > 1) fileType = fileTypes;
     else if (fileTypes.length === 1) fileType = fileTypes[0];
 
+    // Part 1: pattern[] fan-out. Two or more patterns in a content search run
+    // as INDEPENDENT greps (mirroring the path[] batching above): each pattern
+    // keeps its own full head_limit budget and its own truncation notice, and
+    // identical path:line match lines are de-duplicated across patterns. The
+    // single-pattern path and the non-content modes (files_with_matches/count)
+    // keep the combined single-rg behavior. `_grepPatternFanout` guards the
+    // recursive single-pattern calls from re-entering the fan-out; the internal
+    // chunk-merge recursion is likewise skipped.
+    if (patterns.length > 1
+        && outputMode === 'content'
+        && !options._grepChunkMerge
+        && !options._grepPatternFanout) {
+        const seen = new Set();
+        const subOptions = { ...options, _grepPatternFanout: true };
+        const parts = [];
+        for (const p of patterns) {
+            let sub;
+            try {
+                sub = await executeGrepTool({ ...args, pattern: p }, workDir, executeChildBuiltinTool, readStateScope, subOptions);
+            } catch (err) {
+                sub = `Error: ${err && err.message ? err.message : err}`;
+            }
+            parts.push(`# grep pattern:${JSON.stringify(p)}\n${dedupeFanoutMatchLines(sub, seen)}`);
+        }
+        return patternCapNote + parts.join('\n\n');
+    }
+
     const patternChunkCap = multilineMode ? GREP_MULTILINE_PATTERN_CAP : GREP_ARRAY_PATTERN_CAP;
     if (patterns.length > patternChunkCap) {
         const patternChunks = chunkPatternList(patterns, patternChunkCap);
@@ -676,7 +810,7 @@ export async function executeGrepTool(args, workDir, executeChildBuiltinTool, re
         });
     }
 
-    const forceGrepFilename = !!options._grepChunkMerge;
+    const forceGrepFilename = !!options._grepChunkMerge || !!options._grepPatternFanout;
     const cacheKey = buildGrepCacheKey({
         patterns,
         searchPath: normalizeOutputPath(grepResolvedPath),
@@ -775,6 +909,64 @@ export async function executeGrepTool(args, workDir, executeChildBuiltinTool, re
             pcre2: pcre2Mode,
             withFilename: forceGrepFilename,
         });
+        // Parts 2 & 3: context mode windows MATCH BLOCKS (not raw lines); the
+        // total match count and tail blocks come from the streamed (memory-
+        // bounded) collection below.
+        const contextMode = outputMode === 'content' && (beforeN > 0 || afterN > 0 || contextN > 0);
+        if (contextMode) {
+            // Finding 1: stream only enough lines to satisfy the block window
+            // (offset + head_limit + tail reserve), so rg is stopped early and a
+            // broad content_with_context never retains a full 20MB stdout copy.
+            // A cap hit → complete:false → partial (lower-bound) phrasing below.
+            const GREP_CONTEXT_LINE_HARD_CAP = 4000;
+            const perBlock = 2 + (beforeN || 0) + (afterN || 0) + 2 * (contextN || 0);
+            const blockBudget = headLimit === Infinity ? Infinity : offset + headLimit + 4;
+            const lineCap = blockBudget === Infinity
+                ? GREP_CONTEXT_LINE_HARD_CAP
+                : Math.min(GREP_CONTEXT_LINE_HARD_CAP, Math.max(200, blockBudget * Math.max(1, perBlock) + 8));
+            let ctxPartialSuffix = '';
+            const streamed = await runRgWindowedLines(rgArgs, { cwd: rgSpawnCwd }, { offset: 0, limit: lineCap, summaryLimit: 0 });
+            const allLines = streamed.lines;
+            let ctxTotalKnown = streamed.complete;
+            if (streamed.partial) {
+                ctxTotalKnown = false;
+                ctxPartialSuffix = streamed.timeout
+                    ? '\n[warning] rg timed out; partial results shown. Narrow path/glob/pattern for a complete result.'
+                    : streamed.rgStderr
+                    ? `\n[warning] rg exit 2 (partial results): ${String(streamed.rgStderr).trim().slice(0, 300)}`
+                    : '\n[warning] rg exit 2 (partial results)';
+            } else if (!streamed.complete) {
+                ctxPartialSuffix = `\n[warning] context output capped at ${lineCap} lines to bound memory; results partial — narrow path/glob/pattern for the full match set.`;
+            }
+            const ctx = formatGrepContextOutput({
+                allLines,
+                workDir,
+                outputMode,
+                filenameOmitted,
+                headLimit,
+                offset,
+                totalKnown: ctxTotalKnown,
+            });
+            let ctxBody = ctx.text;
+            if (!ctxBody) {
+                const patternStr = patterns.length === 1 ? JSON.stringify(patterns[0]) : JSON.stringify(patterns);
+                const globStr = normalizedGlobPatterns.length > 0 ? ` glob=${JSON.stringify(normalizedGlobPatterns)}` : '';
+                const pathInfo = grepStat.isDirectory() ? 'path exists (dir)' : 'path exists (file)';
+                ctxBody = `(no matches) pattern=${patternStr} path=${searchPath}${globStr}; ${pathInfo}`;
+            }
+            const ctxOut = patternCapNote + ctxBody + ctxPartialSuffix;
+            if (options?.scopedCacheOutcome && (!ctxTotalKnown || ctx.omitted > 0)) {
+                markScopedCacheIncomplete(options.scopedCacheOutcome);
+            }
+            recordGrepReadSnapshot(grepStat);
+            if (ctxTotalKnown && ctx.omitted === 0) {
+                cacheSet(cacheKey, ctxOut, { scopes: [grepResolvedPath] });
+            }
+            if (typeof options?.onProgress === 'function') {
+                try { options.onProgress(`found ${ctx.total} matches`); } catch { /* best-effort */ }
+            }
+            return ctxOut;
+        }
         let windowed;
         let totalWindowed = 0;
         let totalKnown = true;
@@ -832,7 +1024,7 @@ export async function executeGrepTool(args, workDir, executeChildBuiltinTool, re
             globPatterns: normalizedGlobPatterns,
             fileType,
             filenameOmitted,
-            disableContentGrouping: !!options._grepChunkMerge,
+            disableContentGrouping: !!options._grepChunkMerge || !!options._grepPatternFanout,
         });
         if (!body) {
             const pathInfo = grepStat.isDirectory() ? 'path exists (dir)' : 'path exists (file)';

package/src/runtime/agent/orchestrator/tools/builtin.mjs

@@ -297,6 +297,7 @@ const EXTERNAL_TOOL_REDIRECTS = new Map([
     ['codebase_search', 'use the `grep` or `code_graph` tool'],
     ['semanticsearch', 'use the `grep` or `code_graph` tool'],
     ['semantic_search', 'use the `grep` or `code_graph` tool'],
+    ['explore', 'not available in this role — use `grep` or `code_graph` for repo search'],
 ]);
 
 export function canonicalizeBuiltinToolName(name) {
@@ -520,7 +521,22 @@ export async function executeBuiltinTool(name, args, cwd, options = {}) {
     }
     })();
     const _withNudge = _maybeAppendGrepSweepNudge(toolName, args, _toolResult, readStateScope);
-    return capToolOutput(_withNudge, options);
+    return capToolOutput(_appendClampNotices(args, _withNudge), options);
+}
+
+// Surface arg-guard clamp notices (args._clampNotices, see pushClampNotice in
+// arg-guard.mjs) on the result text so the caller learns its request was
+// capped. Delete to consume: prevents double-append when a child-builtin
+// result is embedded in the parent's, and leaves no `_clampNotices` residue
+// on the recorded tool-call args in the transcript.
+function _appendClampNotices(args, result) {
+    let notices = null;
+    if (args && Array.isArray(args._clampNotices)) {
+        notices = args._clampNotices;
+        delete args._clampNotices;
+    }
+    if (!notices || notices.length === 0 || typeof result !== 'string') return result;
+    return `${result}\n\n${notices.map((n) => `[arg-guard] ${n}`).join('\n')}`;
 }
 /**
  * Check if a tool name is a builtin tool.

package/src/runtime/agent/orchestrator/tools/code-graph/dispatch.mjs

@@ -51,6 +51,36 @@ function _collectGraphSymbolList(args) {
 
 const CODE_GRAPH_FILE_BATCH_CAP = 20;
 
+// Absorb: file/files arriving as a JSON-stringified array
+// (file:"[\"a.mjs\",\"b.mjs\"]") — parse to a real array so the graph lookup
+// batches per file instead of treating the JSON text as one (missing) path.
+function _parseJsonArrayString(v) {
+  if (typeof v !== 'string') return null;
+  const t = v.trim();
+  if (!t.startsWith('[') || !t.endsWith(']')) return null;
+  try {
+    const parsed = JSON.parse(t);
+    if (Array.isArray(parsed)) return parsed.map((x) => String(x || '').trim()).filter(Boolean);
+  } catch { /* not JSON — leave untouched */ }
+  return null;
+}
+
+function _normalizeGraphFileArgs(args) {
+  if (!args || typeof args !== 'object') return args;
+  const fileArr = _parseJsonArrayString(args.file);
+  const filesArr = _parseJsonArrayString(args.files);
+  if (!fileArr && !filesArr) return args;
+  const out = { ...args };
+  if (fileArr) { out.files = Array.isArray(out.files) ? [...fileArr, ...out.files] : fileArr; delete out.file; }
+  if (filesArr) out.files = filesArr;
+  // Collapse a lone entry back to the single-file field for the fast path.
+  if (Array.isArray(out.files) && out.files.length === 1 && !out.file) {
+    out.file = out.files[0];
+    delete out.files;
+  }
+  return out;
+}
+
 function _collectGraphFileList(args) {
   const split = (s) => String(s || '').split(/,+/).map((t) => t.trim()).filter(Boolean);
   const list = [...new Set([
@@ -70,6 +100,13 @@ async function codeGraph(args, cwd, signal = null, options = {}) {
   let mode = String(args?.mode || '').trim();
   if (!mode) throw new Error('code_graph: "mode" is required');
   if (mode === 'search') mode = 'symbol_search';
+  // Name-only "symbols" calls (symbols[]/symbol without a file) are symbol
+  // lookups, not a file outline — absorb into symbol_search instead of
+  // erroring "file not found in graph: (missing file)".
+  if (mode === 'symbols' && !String(args?.file || '').trim()
+      && ((Array.isArray(args?.symbols) && args.symbols.length) || String(args?.symbol || '').trim())) {
+    mode = 'symbol_search';
+  }
 
   if (mode === 'prewarm') {
     const _splitMulti = (s) => String(s || '').split(/[,\s]+/).map((t) => t.trim()).filter(Boolean);
@@ -436,6 +473,7 @@ export async function resolveSymbolReadSpan(cwd, { symbol, path = null, language
 
 export async function executeCodeGraphTool(name, args, cwd, signal = null, options = {}) {
   if (!cwd) throw new Error('find_symbol/code_graph requires cwd — caller did not provide a working directory');
+  args = _normalizeGraphFileArgs(args);
   const fileArg = (args && typeof args.file === 'string' && args.file.trim()) ? args.file.trim() : '';
   const baseCwd = (args && typeof args.cwd === 'string' && args.cwd.trim()) ? args.cwd.trim() : cwd;
   let effectiveCwd = baseCwd;

package/src/runtime/agent/orchestrator/tools/code-graph-tool-defs.mjs

@@ -3,13 +3,13 @@ export const CODE_GRAPH_TOOL_DEFS = [
     name: 'code_graph',
     title: 'Code Graph',
     annotations: { title: 'Code Graph', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false, compressible: false, compressibleLossless: true },
-    description: 'Repo-local code structure/flow lookup, not web: symbols/references/calls/deps before text grep. Multiple targets = ONE call with symbols[]/files[], never parallel single-target calls.',
+    description: 'Repo-local code structure/flow lookup (not web): symbols/references/calls/deps. Batch targets as symbols[]/files[] in one call.',
     inputSchema: {
       type: 'object',
       properties: {
-        mode: { type: 'string', enum: ['overview', 'imports', 'dependents', 'related', 'impact', 'symbols', 'find_symbol', 'symbol_search', 'search', 'references', 'callers'], description: 'Repo-local operation; code flow before text search.' },
-        files: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' }, minItems: 1 }], description: 'Source file(s): string or array; one call fans out per file (imports/dependents/related/impact/symbols/overview). `file` singular alias also accepted.' },
-        symbols: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' }, minItems: 1 }], description: 'Identifier(s)/keyword(s): string or array; batch in one call. One anchor is enough. `symbol` singular alias also accepted.' },
+        mode: { type: 'string', enum: ['overview', 'imports', 'dependents', 'related', 'impact', 'symbols', 'find_symbol', 'symbol_search', 'search', 'references', 'callers'], description: 'Repo-local graph operation.' },
+        files: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' }, minItems: 1 }], description: 'Source file(s); array fans out per file. `file` alias too.' },
+        symbols: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' }, minItems: 1 }], description: 'Identifier(s)/keyword(s); array batches in one call. `symbol` alias too.' },
         symbol: { type: 'string', description: 'Singular alias for symbols.' },
         file: { type: 'string', description: 'Singular alias for files.' },
         body: { type: 'boolean', description: 'Include body.' },

package/src/runtime/agent/orchestrator/tools/shell-state.mjs

@@ -1,5 +1,5 @@
 'use strict';
-// Claude Code-style shell state carry-over for the one-shot shell tool.
+// Shell state carry-over for the one-shot shell tool.
 //
 // No live shell process is kept. Instead, after each sync command we chain a
 // trailing cwd probe that writes the final working directory to a per-session

package/src/runtime/channels/backends/discord-gateway.mjs

@@ -205,13 +205,24 @@ function registerShardListeners(self) {
 
 async function awaitLogin(self) {
   let readyTimeout;
+  // Adaptive ready timeout: grow on consecutive login failures (30s→60s→90s
+  // cap) so an identify delayed by gateway rate-limiting can still complete
+  // its READY handshake instead of tripping a fixed 30s timeout every retry.
+  const readyMs = Math.min(90_000, 30_000 + (self._loginFailures || 0) * 30_000);
   const readyPromise = new Promise((resolve, reject) => {
-    readyTimeout = setTimeout(() => reject(new Error("discord ready timeout (30s)")), 3e4);
+    readyTimeout = setTimeout(
+      () => reject(new Error(`discord ready timeout (${Math.round(readyMs / 1000)}s)`)),
+      readyMs
+    );
     self.client.once(self._discordEvents().ClientReady, () => {
       clearTimeout(readyTimeout);
       resolve();
     });
   });
+  // Guarantee the ready-timeout rejection can never surface as a process-global
+  // unhandledRejection regardless of how the race below settles: attach an
+  // absorbing handler; the real handling still happens via the awaits.
+  readyPromise.catch(() => {});
   // Observe the ready timer from the start: login() can hang past the 30s
   // timer (gateway reconnect), and a rejection on an un-awaited readyPromise
   // becomes a process-global unhandledRejection → fatal crash path
@@ -225,7 +236,9 @@ async function awaitLogin(self) {
   try {
     await Promise.race([loginPromise, readyPromise]);
     await readyPromise;
+    self._loginFailures = 0;
   } catch (err) {
+    self._loginFailures = (self._loginFailures || 0) + 1;
     clearTimeout(readyTimeout);
     throw err;
   }

package/src/runtime/channels/backends/discord.mjs

@@ -28,6 +28,12 @@ const MAX_CHUNK_LIMIT = MAX_DISCORD_MESSAGE;
 // which upstream leaves the forwarder's `sending` flag stuck and silences all
 // outbound. On timeout we treat the client as dead and reset+reconnect it.
 const SEND_ATTEMPT_TIMEOUT_MS = 30_000;
+// Reconnect backoff: consecutive _resetClient failures back off exponentially
+// with jitter up to a cap so a wedged/rate-limited gateway is not hammered with
+// fixed sub-minute destroy()/login() cycles (that fixed cadence triggered
+// Discord identify rate-limiting → the ready-timeout death loop).
+const RESET_BACKOFF_BASE_MS = 2_000;
+const RESET_BACKOFF_CAP_MS = 60_000;
 // After a timed-out send is reset, cap how long we wait for the original
 // (abandoned) promise to actually settle before giving up with unknown outcome.
 const SETTLE_CAP_MS = 15_000;
@@ -49,7 +55,12 @@ class DiscordBackend {
   initialAccess;
   recentSentIds = /* @__PURE__ */ new Set();
   sendCount = 0;
+  _resetFailures = 0;
+  _loginFailures = 0;
   typingIntervals = /* @__PURE__ */ new Map();
+  // In-flight sendMessage() promises, awaited by drainPendingSends() before a
+  // handoff disconnect so a reply is not cut off mid-delivery.
+  _pendingSends = /* @__PURE__ */ new Set();
   constructor(config, stateDir) {
     this.token = config.token;
     this.mainChannelId = config.mainChannelId ?? "";
@@ -114,11 +125,24 @@ class DiscordBackend {
   async _resetClient() {
     if (this._resetPromise) return this._resetPromise;
     this._resetPromise = (async () => {
+      // Back off before rebuilding: on repeated reset failures wait an
+      // exponentially growing (jittered) delay capped at RESET_BACKOFF_CAP_MS
+      // so we never re-identify in a tight loop.
+      const n = this._resetFailures || 0;
+      if (n > 0) {
+        const cap = Math.min(RESET_BACKOFF_CAP_MS, RESET_BACKOFF_BASE_MS * 2 ** (n - 1));
+        const delay = Math.floor(cap / 2 + Math.random() * (cap / 2));
+        await new Promise((r) => setTimeout(r, delay));
+      }
       try { this.client?.destroy?.(); } catch {}
       this.client = null;
       this._connectPromise = null;
       await this.connect();
-    })().finally(() => { this._resetPromise = null; });
+      this._resetFailures = 0;
+    })().catch((err) => {
+      this._resetFailures = (this._resetFailures || 0) + 1;
+      throw err;
+    }).finally(() => { this._resetPromise = null; });
     return this._resetPromise;
   }
   /** Health-check the gateway; reset+reconnect if the ws is not READY. Called
@@ -154,7 +178,25 @@ class DiscordBackend {
     }
   }
   // ── Outbound operations ────────────────────────────────────────────
+  // Public entry: tracks the send so drainPendingSends() can await in-flight
+  // deliveries before an ownership-handoff disconnect. Delegates to the impl.
   async sendMessage(chatId, text, opts) {
+    const p = this._sendMessageImpl(chatId, text, opts);
+    const tracked = Promise.resolve(p).catch(() => {});
+    this._pendingSends.add(tracked);
+    tracked.finally(() => this._pendingSends.delete(tracked));
+    return p;
+  }
+  /** Await in-flight sends (bounded) so a handoff drains outbound before
+   *  disconnect. Bounded by timeoutMs so a wedged send can't stall teardown. */
+  async drainPendingSends(timeoutMs = 4000) {
+    if (this._pendingSends.size === 0) return;
+    await Promise.race([
+      Promise.allSettled([...this._pendingSends]),
+      new Promise((r) => setTimeout(r, timeoutMs)),
+    ]);
+  }
+  async _sendMessageImpl(chatId, text, opts) {
     const ch = await this.fetchAllowedChannel(chatId);
     if (!("send" in ch)) throw new Error("channel is not sendable");
     const files = opts?.files ?? [];