mixdog 0.9.96 → 0.9.97

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

@@ -144,8 +144,8 @@ function restorePatchRollbackState(snapshots, readStateScope) {
 }
 
 // Apply one "wave" (a set of unique-target parsed entries) via the native
-// (+ JS out-of-base) split. Returns { backend, text } on success or
-// { backend, error } so the caller decides whether earlier waves already
+// (+ JS out-of-base) split. Returns { executor, text } on success or
+// { executor, error } so the caller decides whether earlier waves already
 // committed to disk. Extracted verbatim from the inline applyWave closure so
 // both the default wave loop and sequence mode share identical apply
 // semantics.
@@ -156,7 +156,7 @@ async function applyParsedWave({ parsed: wparsed, entries: wentries, headerRewri
   const parsedInside = (wparsed || []).filter(
     (entry) => !isResolvedPathOutsideBase(parsedEntryResolvedPath(entry, basePath), basePath),
   );
-  const backend = outsideEntries.length > 0
+  const executor = outsideEntries.length > 0
     ? (insideEntries.length > 0 ? 'native+js-patch' : 'js-patch')
     : 'native-patch';
   const resultParts = [];
@@ -173,7 +173,7 @@ async function applyParsedWave({ parsed: wparsed, entries: wentries, headerRewri
       signal: abortSignal,
       parsed: parsedInside,
     });
-    if (isPatchErrorText(nativeResult)) return { backend, error: nativeResult };
+    if (isPatchErrorText(nativeResult)) return { executor, error: nativeResult };
     resultParts.push(nativeResult);
   }
   if (outsideEntries.length > 0) {
@@ -187,10 +187,10 @@ async function applyParsedWave({ parsed: wparsed, entries: wentries, headerRewri
       fuzzy,
       readStateScope,
     });
-    if (isPatchErrorText(jsResult)) return { backend, error: jsResult };
+    if (isPatchErrorText(jsResult)) return { executor, error: jsResult };
     resultParts.push(jsResult);
   }
-  return { backend, text: resultParts.join('\n') };
+  return { executor, text: resultParts.join('\n') };
 }
 
 // Default ordered section mode. Apply each file section in listed order,
@@ -384,7 +384,7 @@ async function applyPatchSequence(patchStr, requestedFormat, basePath, ctx) {
       const skipped = [];
       let failed = null;
       let failedIndex = -1;
-      let backend = 'native-patch';
+      let executor = 'native-patch';
       for (let i = 0; i < units.length; i++) {
         const unit = units[i];
         if (failed) { skipped.push(unit.displayPath); continue; }
@@ -421,7 +421,7 @@ async function applyPatchSequence(patchStr, requestedFormat, basePath, ctx) {
           }
         }
         const res = await applyParsedWave(wave, basePath, waveOpts);
-        backend = res.backend;
+        executor = res.executor;
         if (res.error) {
           failed = { displayPath: unit.displayPath, error: res.error };
           failedIndex = i;
@@ -459,7 +459,7 @@ async function applyPatchSequence(patchStr, requestedFormat, basePath, ctx) {
         }
         const head = `apply_patch: ${verb} ${units.length} section(s)`;
         const body = (appliedTexts ? `${head}\n${appliedTexts}` : head) + dryNote + rejectedTail;
-        return wrapPatchMutationOutput(body, mutationPlan, { backend });
+        return wrapPatchMutationOutput(body, mutationPlan, { executor });
       }
       const failMsg = failed.error.replace(/^Error:\s*/, '');
       const rollbackErrors = (!dryRun && rollbackOnFailure)
@@ -499,7 +499,7 @@ async function applyPatchSequence(patchStr, requestedFormat, basePath, ctx) {
       if (skipped.length > 0) {
         lines.push(`--- skipped (not attempted): ${skipped.join(', ')} ---`);
       }
-      return wrapPatchMutationOutput(lines.join('\n') + dryNote + rejectedTail, mutationPlan, { backend });
+      return wrapPatchMutationOutput(lines.join('\n') + dryNote + rejectedTail, mutationPlan, { executor });
     }));
 }
 
@@ -723,9 +723,41 @@ function salvageShatteredV4APatchArgs(args) {
   return cleaned;
 }
 
+function extractInlinePatchRoot(patchText) {
+  const text = String(patchText || '');
+  const match = /^(\*\*\* Begin Patch\r?\n)\*\*\* Root:[ \t]*(.*?)\r?\n/.exec(text);
+  if (!match) return { patch: text, root: null };
+  const root = String(match[2] || '').trim();
+  if (!root) throw new Error('apply_patch: "*** Root:" requires a containing directory');
+  return {
+    patch: `${match[1]}${text.slice(match[0].length)}`,
+    root,
+  };
+}
+
+function isFilesystemRootSpecifier(value, cwd) {
+  const raw = String(value || '').trim();
+  if (!raw) return false;
+  // Keep Windows semantics testable on every host and reject the ambiguous
+  // drive-relative spelling (`C:`) alongside an actual drive root.
+  if (/^[A-Za-z]:(?:[\\/]?)$/.test(raw)) return true;
+  const resolved = resolveBasePath(cwd, raw);
+  return pathDirname(resolved) === resolved;
+}
+
 async function apply_patch(args, cwd, options = {}) {
   args = salvageShatteredV4APatchArgs(args);
-  const patchStr = salvageV4AOpening((typeof args?.patch === 'string' ? args.patch : '').replace(/^\uFEFF/, ''));
+  let patchStr = salvageV4AOpening((typeof args?.patch === 'string' ? args.patch : '').replace(/^\uFEFF/, ''));
+  const inlineRoot = extractInlinePatchRoot(patchStr);
+  patchStr = inlineRoot.patch;
+  if (inlineRoot.root) {
+    const argumentRoot = typeof args?.root === 'string' ? args.root.trim() : '';
+    if (argumentRoot
+        && pathResolve(resolveBasePath(cwd, argumentRoot)) !== pathResolve(resolveBasePath(cwd, inlineRoot.root))) {
+      throw new Error('apply_patch: root argument conflicts with the "*** Root:" directive');
+    }
+    args = { ...(args || {}), root: inlineRoot.root };
+  }
   if (!patchStr.trim()) {
     throw new Error('apply_patch: "patch" is required (unified diff or V4A patch string)');
   }
@@ -761,7 +793,21 @@ async function apply_patch(args, cwd, options = {}) {
   // a mis-scoped working directory can never silently rewrite another tree.
   // Editing outside stays possible, but only as a deliberate act: name the
   // root that contains those targets in the same call.
-  const writeRoot = resolveBasePath(cwd, args?.root ?? args?.base_path ?? null);
+  const explicitRoot = typeof args?.root === 'string' && args.root.trim() ? args.root.trim() : null;
+  if (explicitRoot && isFilesystemRootSpecifier(explicitRoot, cwd)) {
+    throw new Error(`apply_patch: refusing filesystem root as write root: ${normalizeOutputPath(explicitRoot)}`);
+  }
+  const writeRoot = resolveBasePath(cwd, explicitRoot ?? args?.base_path ?? null);
+  if (explicitRoot) {
+    try {
+      await assertPathReachable(writeRoot);
+      if (!statSync(writeRoot).isDirectory()) {
+        throw new Error(`not a directory — ${normalizeOutputPath(writeRoot)}`);
+      }
+    } catch (err) {
+      throw new Error(`apply_patch: invalid write root ${normalizeOutputPath(writeRoot)}: ${err?.message || String(err)}`);
+    }
+  }
   const outsideTargets = [];
   for (const rel of patchTargetPaths(patchStr, basePath)) {
     const abs = isAbsolute(rel) ? pathResolve(rel) : pathResolve(basePath, rel);
@@ -773,7 +819,7 @@ async function apply_patch(args, cwd, options = {}) {
     const more = shown.length > 3 ? ` (+${shown.length - 3} more)` : '';
     throw new Error(
       `apply_patch: ${shown.length} target(s) fall outside the write root ${normalizeOutputPath(writeRoot)}: ${head}${more}. `
-      + 'Check the paths first; if they are intended, re-issue the same patch with root set to the directory that contains them.',
+      + 'Check the paths first; if intended, set root (JSON) or add "*** Root: <containing directory>" after "*** Begin Patch" (freeform).',
     );
   }
   const rejectPartial = args?.reject_partial !== false;
@@ -917,17 +963,17 @@ async function apply_patch(args, cwd, options = {}) {
     if (v4aRenameOnly) {
       const lines = formatV4ARenameSuccessLines(v4aRenameResults);
       if (lines.length === 0) return 'Error: patch contained no applicable file sections';
-      return wrapPatchMutationOutput(`${lines.join('\n')}\n`, mutationPlan, { backend: 'v4a-rename' });
+      return wrapPatchMutationOutput(`${lines.join('\n')}\n`, mutationPlan, { executor: 'v4a-rename' });
     }
     // Apply one wave (a set of unique targets) via applyParsedWave (native +
-    // JS split). Returns { backend, text } on success or { backend, error }.
+    // JS split). Returns { executor, text } on success or { executor, error }.
     const applyWave = (wave) => applyParsedWave(wave, basePath, { fuzz, rejectPartial, dryRun, fuzzy, readStateScope, abortSignal });
 
     // Duplicate-target blocks were split into contiguous sequential groups
     // (listed order preserved); apply them in order, each against the prior
     // group's on-disk result.
     const waveTexts = [];
-    let backend = 'native-patch';
+    let executor = 'native-patch';
     // dry_run never writes, so a later group would validate against unchanged
     // disk and false-fail on any block that depends on an earlier edit. Only
     // the first group is validated under dry_run; the rest are reported as
@@ -935,9 +981,9 @@ async function apply_patch(args, cwd, options = {}) {
     const groupCount = (dryRun && waveDispatch.length > 1) ? 1 : waveDispatch.length;
     for (let w = 0; w < groupCount; w++) {
       const res = await applyWave(waveDispatch[w]);
-      backend = res.backend;
+      executor = res.executor;
       if (res.error) {
-        if (w === 0) return wrapPatchMutationOutput(res.error, mutationPlan, { backend });
+        if (w === 0) return wrapPatchMutationOutput(res.error, mutationPlan, { executor });
         // A later group failed. rejectPartial makes each group all-or-nothing,
         // so every block in groups 1..w is fully committed to disk and left in
         // place. List them all so the caller knows the true on-disk state.
@@ -948,7 +994,7 @@ async function apply_patch(args, cwd, options = {}) {
           '--- failing block ---',
           failMsg,
         ].join('\n');
-        return wrapPatchMutationOutput(note, mutationPlan, { backend });
+        return wrapPatchMutationOutput(note, mutationPlan, { executor });
       }
       waveTexts.push(res.text);
     }
@@ -970,9 +1016,9 @@ async function apply_patch(args, cwd, options = {}) {
         `hunk-level rejected (rejectPartial=false, V4A): ${rejectedV4AHunks.length}`,
         ...rejectedV4AHunks.map((r) => `  REJECT ${r.file || '(unknown)'} — ${String(r.reason || '').split(';')[0].trim()}`),
       ];
-      return wrapPatchMutationOutput(`${combined}\n${tail.join('\n')}`, mutationPlan, { backend });
+      return wrapPatchMutationOutput(`${combined}\n${tail.join('\n')}`, mutationPlan, { executor });
     }
-    return wrapPatchMutationOutput(combined, mutationPlan, { backend });
+    return wrapPatchMutationOutput(combined, mutationPlan, { executor });
   };
 
   return withBuiltinPathLocks(_lockPaths, () =>

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

@@ -1,5 +1,6 @@
-const APPLY_PATCH_LARK_GRAMMAR = `start: begin_patch hunk+ end_patch
+const APPLY_PATCH_LARK_GRAMMAR = `start: begin_patch root_line? hunk+ end_patch
 begin_patch: "*** Begin Patch" LF
+root_line: "*** Root: " filename LF
 end_patch: "*** End Patch" LF?
 
 hunk: add_hunk | delete_hunk | update_hunk

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

@@ -20,7 +20,7 @@
 //   ./patch/orchestrator.mjs  — apply_patch orchestration + executePatchTool
 //     + replay capture + UI-diff side-channel.
 //
-// Backend is unchanged: NATIVE-ONLY dispatch to the mixdog-patch Rust engine,
+// Executor is unchanged: NATIVE-ONLY dispatch to the mixdog-patch Rust engine,
 // no JS apply fallback. Public exports below match the pre-split surface.
 
 // Side-effect import: schedules the native-patch prewarm on module load, as

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

@@ -258,6 +258,7 @@ export function execShellCommand({
   ownerSessionId,
   backgroundOnTimeout,
   promotedTimeoutMs = 0,
+  backgroundDeadlineMs = 0,
   admission = resourceAdmission,
 }) {
   return new Promise(async (resolve) => {
@@ -791,7 +792,12 @@ export function execShellCommand({
       const stdoutPath = taskOutput.spilled ? taskOutput.stdoutPath : null;
       const stderrPath = taskOutput.spilled ? taskOutput.stderrPath : null;
       let job = null;
-      const adoptedTimeoutMs = reason === 'timeout' ? promotedTimeoutMs : 0;
+      const elapsedMs = Math.max(0, Date.now() - _startMs);
+      const adoptedTimeoutMs = reason === 'timeout'
+        ? promotedTimeoutMs
+        : (backgroundDeadlineMs > 0
+          ? Math.max(1, backgroundDeadlineMs - elapsedMs)
+          : 0);
       try {
         job = adoptForegroundShellJob({
           command,

package/src/runtime/channels/lib/config.mjs

@@ -1,7 +1,7 @@
 import { readFileSync, mkdirSync } from "fs";
 import { join } from "path";
-import { DiscordBackend } from "../backends/discord.mjs";
-import { TelegramBackend } from "../backends/telegram.mjs";
+import { DiscordProvider } from "../providers/discord.mjs";
+import { TelegramProvider } from "../providers/telegram.mjs";
 import {
   readSection,
   updateSection,
@@ -22,7 +22,7 @@ const DEFAULT_ACCESS = {
   channels: {}
 };
 const DEFAULT_CONFIG = {
-  backend: "discord",
+  provider: "discord",
   discord: { token: "" },
   telegram: { token: "" },
   access: DEFAULT_ACCESS,
@@ -40,18 +40,18 @@ function applyDefaults(config) {
   return out;
 }
 
-function channelIdForBackend(entry = {}, backend = "discord") {
-  if (backend === "telegram") {
-    return String(entry?.telegramChatId || (entry?.discordChannelId ? "" : entry?.channelId) || "");
+function channelIdForProvider(entry = {}, provider = "discord") {
+  if (provider === "telegram") {
+    return String(entry?.telegramChatId || "");
   }
-  return String(entry?.discordChannelId || (entry?.telegramChatId ? "" : entry?.channelId) || "");
+  return String(entry?.discordChannelId || "");
 }
 
-// Resolve the single active-backend channel id from the config's `channel`
+// Resolve the single active-provider channel id from the config's `channel`
 // section. Disk config carries a single `channel` object only.
-function resolveChannelId(raw = {}, backend = "discord") {
+function resolveChannelId(raw = {}, provider = "discord") {
   const channel = raw.channel && typeof raw.channel === "object" ? raw.channel : null;
-  if (channel) return channelIdForBackend(channel, backend);
+  if (channel) return channelIdForProvider(channel, provider);
   return "";
 }
 
@@ -88,20 +88,20 @@ async function loadConfig({ freshSecrets = false } = {}) {
     if (discordTokenProblem) {
       process.stderr.write(`mixdog: discord token ignored: ${discordTokenProblem}\n`);
     }
-    // Single-backend select: config.backend picks ONE of discord|telegram.
+    // Single-provider select: config.provider picks ONE of discord|telegram.
     // Anything else falls back to the discord default.
-    const backend = raw.backend === "telegram" ? "telegram" : "discord";
+    const provider = raw.provider === "telegram" ? "telegram" : "discord";
     const telegramToken = getTelegramToken();
-    const channelId = resolveChannelId(raw, backend);
+    const channelId = resolveChannelId(raw, provider);
     // The runtime reads only the resolved `channelId`; disk carries a single
     // `channel` object, so spread `raw` directly.
     return applyDefaults({
       ...DEFAULT_CONFIG,
       ...raw,
-      backend,
+      provider,
       channelId,
       discord: { ...DEFAULT_CONFIG.discord, ...(({ token: _, ...rest }) => rest)(raw.discord || {}), ...(discordToken && !discordTokenProblem ? { token: discordToken } : {}) },
-      // Merge the keychain-resolved telegram token (harmless when backend is
+      // Merge the keychain-resolved telegram token (harmless when provider is
       // discord; the secret never lands in the on-disk config either way).
       telegram: { ...DEFAULT_CONFIG.telegram, ...(({ token: _t, ...rest }) => rest)(raw.telegram || {}), ...(telegramToken ? { token: telegramToken } : {}) },
       access: {
@@ -117,7 +117,7 @@ async function loadConfig({ freshSecrets = false } = {}) {
       updateSection("channels", () => DEFAULT_CONFIG);
       process.stderr.write(
         `mixdog: default channels config created in ${MIXDOG_CONFIG_PATH}
-  edit the active backend channel id to connect.
+  edit the active provider channel id to connect.
 `
       );
       return applyDefaults(DEFAULT_CONFIG);
@@ -125,7 +125,7 @@ async function loadConfig({ freshSecrets = false } = {}) {
     throw err;
   }
 }
-const HEADLESS_BACKEND = {
+const HEADLESS_PROVIDER = {
   name: "headless",
   MAX_MESSAGE_LENGTH: 2000,
   formatOutgoing(t) {
@@ -156,31 +156,31 @@ const HEADLESS_BACKEND = {
   on() {
   }
 };
-function createBackend(config) {
+function createProvider(config) {
   // Channels-module toggle is MESSAGING-ONLY: automation (scheduler/webhooks)
-  // keeps the worker alive, so a disabled module runs the headless backend
+  // keeps the worker alive, so a disabled module runs the headless provider
   // instead of blocking the whole runtime.
   if (config.enabled === false) {
     process.stderr.write("mixdog: channels messaging disabled; channel runtime running in headless mode\n");
-    return HEADLESS_BACKEND;
+    return HEADLESS_PROVIDER;
   }
-  // Single-backend select: exactly one backend is constructed based on
-  // config.backend (discord|telegram). The two are mutually exclusive.
-  if (config.backend === "telegram") {
+  // Single-provider select: exactly one provider is constructed based on
+  // config.provider (discord|telegram). The two are mutually exclusive.
+  if (config.provider === "telegram") {
     const telegramToken = getTelegramToken();
     if (!telegramToken) {
       process.stderr.write("mixdog: telegram bot not configured; channel runtime running in headless mode\n");
-      return HEADLESS_BACKEND;
+      return HEADLESS_PROVIDER;
     }
     const tgStateDir = config.telegram?.stateDir ?? join(DATA_DIR, "telegram");
     mkdirSync(tgStateDir, { recursive: true });
-    return new TelegramBackend({
+    return new TelegramProvider({
       ...config.telegram,
       configPath: CONFIG_FILE,
       access: config.access,
       // Single-source channel setup: the main chat is auto-allowed inside
-      // TelegramBackend.loadAccess() so a configured channel.channelId
-      // is enough for both inbound gating and outbound.
+      // TelegramProvider.loadAccess() so the configured Telegram target is
+      // enough for both inbound gating and outbound.
       mainChannelId: config.channelId
     }, tgStateDir);
   }
@@ -189,19 +189,19 @@ function createBackend(config) {
   if (discordTokenProblem) {
     process.stderr.write(`mixdog: discord token ignored: ${discordTokenProblem}\n`);
   }
-  if (config.backend !== "discord" || !discordToken || discordTokenProblem) {
+  if (config.provider !== "discord" || !discordToken || discordTokenProblem) {
     process.stderr.write("mixdog: discord bot not configured; channel runtime running in headless mode\n");
-    return HEADLESS_BACKEND;
+    return HEADLESS_PROVIDER;
   }
   const stateDir = config.discord.stateDir ?? join(DATA_DIR, "discord");
   mkdirSync(stateDir, { recursive: true });
-  return new DiscordBackend({
+  return new DiscordProvider({
     ...config.discord,
     configPath: CONFIG_FILE,
     access: config.access,
     // Single-source channel setup: the main channel is auto-allowed inside
-    // DiscordBackend.loadAccess() so a configured channel.channelId
-    // is enough for both inbound and outbound — no separate access.channels entry.
+    // DiscordProvider.loadAccess() so the configured Discord target is enough
+    // for both inbound and outbound — no separate access.channels entry.
     mainChannelId: config.channelId
   }, stateDir);
 }
@@ -215,7 +215,7 @@ function loadProfileConfig() {
 }
 export {
   DATA_DIR,
-  createBackend,
+  createProvider,
   getDiscordToken,
   getTelegramToken,
   loadConfig,

package/src/runtime/channels/lib/inbound-handler.mjs

@@ -7,14 +7,14 @@ import {
 import { refreshActiveInstance } from "./runtime-paths.mjs";
 import { isNetworkError, retryOnNetwork } from "./network-retry.mjs";
 // Inbound message pipeline extracted from channels/index.mjs (behavior-
-// preserving): serial inbound queue, backend.onMessage transcript (re)bind +
+// preserving): serial inbound queue, provider.onMessage transcript (re)bind +
 // steal logic, and handleInbound voice-transcription + parent notify. Bound to
 // live runtime getters and shared primitives.
 function isImageAttachment(contentType) {
   return typeof contentType === "string" && contentType.toLowerCase().startsWith("image/");
 }
 export function createInboundHandler({
-  getBackend,
+  getProvider,
   getConfig,
   getBridgeRuntimeConnected,
   getChannelBridgeActive,
@@ -55,7 +55,7 @@ const inboundQueue = (() => {
   };
 })();
 
-getBackend().onMessage = (msg) => {
+getProvider().onMessage = (msg) => {
   const receivedAtMs = Number.isFinite(msg.receivedAtMs) ? msg.receivedAtMs : Date.now();
   const onMessageAtMs = Date.now();
   const gateBlocked = (!getBridgeRuntimeConnected() || !getBridgeOwnershipSnapshot().owned)
@@ -72,7 +72,7 @@ getBackend().onMessage = (msg) => {
       msg.__bridgeGateRetries = attempt;
       msg.receivedAtMs = receivedAtMs;
       setTimeout(() => {
-        try { getBackend().onMessage?.(msg); } catch { /* best-effort */ }
+        try { getProvider().onMessage?.(msg); } catch { /* best-effort */ }
       }, 2000 * attempt)?.unref?.();
     } else {
       try { process.stderr.write(`mixdog: inbound message dropped after ${attempt - 1} ${gateBlocked} retries (channel=${msg.chatId}, id=${msg.messageId})\n`); } catch {}
@@ -242,7 +242,7 @@ getBackend().onMessage = (msg) => {
   });
   void (async () => {
     try {
-      await getBackend().react(msg.chatId, msg.messageId, "\u{1F914}");
+      await getProvider().react(msg.chatId, msg.messageId, "\u{1F914}");
     } catch {
     }
     await bindingDone;
@@ -271,7 +271,7 @@ async function handleInbound(msg, route, options = {}) {
         const files = await retryOnNetwork(
           // Short per-attempt timeout (vs the 180s default) bounds worst-case
           // blockage of the serial inboundQueue on a bad voice message.
-          () => getBackend().downloadAttachment(msg.chatId, msg.messageId, { timeoutMs: 20_000 }),
+          () => getProvider().downloadAttachment(msg.chatId, msg.messageId, { timeoutMs: 20_000 }),
           { label: "voice.download" }
         );
         // concurrency handled inside transcribeVoice queue; loop is sequential so last att wins
@@ -312,7 +312,7 @@ async function handleInbound(msg, route, options = {}) {
   if (imageAtts.length > 0) {
     try {
       const files = (await retryOnNetwork(
-        () => getBackend().downloadAttachment(msg.chatId, msg.messageId, {
+        () => getProvider().downloadAttachment(msg.chatId, msg.messageId, {
           timeoutMs: 20_000,
           filter: (a) => isImageAttachment(a.contentType),
         }),

package/src/runtime/channels/lib/interaction-handlers.mjs

@@ -1,11 +1,11 @@
 import * as fs from "fs";
 import * as path from "path";
 // Discord permission-prompt + interaction/modal routing extracted from
-// channels/index.mjs (behavior-preserving). Installs backend.onInteraction /
+// channels/index.mjs (behavior-preserving). Installs provider.onInteraction /
 // onModalRequest handlers and the terminal tool-exec signal watcher; returns the
 // pending-permission map + marker refresher for the worker IPC handler.
 export function createInteractionHandlers({
-  getBackend,
+  getProvider,
   getConfig,
   getBridgeRuntimeConnected,
   instanceId,
@@ -30,18 +30,18 @@ export function createInteractionHandlers({
   RUNTIME_ROOT,
 }) {
 function editDiscordMessage(channelId, messageId, label) {
-  // Behavior-preserving: route through the getBackend() abstraction (which uses
+  // Behavior-preserving: route through the getProvider() abstraction (which uses
   // discord.js under the hood) instead of issuing a raw REST PATCH. Errors
   // are swallowed to stderr to match the prior fire-and-forget shape — the
   // call site never awaited the HTTPS request either.
   if (!getDiscordToken()) return;
   const text = `\u{1F510} **Permission Request** \u2014 ${label}`;
-  void getBackend().editMessage(channelId, messageId, text, { components: [] }).catch((err) => {
+  void getProvider().editMessage(channelId, messageId, text, { components: [] }).catch((err) => {
     process.stderr.write(`mixdog: editDiscordMessage failed: ${err}
 `);
   });
 }
-getBackend().onModalRequest = async (rawInteraction) => {
+getProvider().onModalRequest = async (rawInteraction) => {
   if (!getBridgeRuntimeConnected() || !getBridgeOwnershipSnapshot().owned) {
     refreshBridgeOwnershipSafe();
     return;
@@ -155,7 +155,7 @@ try {
   try { process.stderr.write(`mixdog channels: tool-exec signal watcher setup failed: ${err && err.message || err}\n`); } catch {}
 }
 
-getBackend().onInteraction = (interaction) => {
+getProvider().onInteraction = (interaction) => {
   // Channel-route permission reply. Custom_id format: perm-ch-{request_id}-{allow|session|deny}.
   // request_id is the 5-letter short ID CC generates via shortRequestId().
   // Emit notifications/claude/channel/permission back to the MCP host; the race