mixdog 0.9.51 → 0.9.53

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

@@ -33,15 +33,18 @@ import { randomUUID } from 'node:crypto';
 import * as nodeUtil from 'node:util';
 import { getPluginData } from '../config.mjs';
 import { startChildGuardian } from '../../../shared/child-guardian.mjs';
+import { resourceAdmission } from '../../../shared/resource-admission.mjs';
 // Runtime-only import (used inside execShellCommand's auto-background
 // transition). shell-jobs.mjs imports stripAnsi from this module, so this is
 // a static cycle — safe because neither binding is touched at module-eval
 // time, only when the respective functions actually run.
 import { adoptForegroundShellJob, killShellJob } from './builtin/shell-jobs.mjs';
+import { trackProcessTreeQuiescence } from './builtin/shell-job-process.mjs';
 import {
   _maybeEncodePowerShellCommand,
   extractPowerShellCommandInner,
 } from './shell-powershell.mjs';
+import { spawnShellWithRetry as _spawnShellWithRetry } from './lib/shell-spawn-retry.mjs';
 
 export {
   _maybeEncodePowerShellCommand,
@@ -445,12 +448,6 @@ async function _execPolicyBlockMessage(command) {
 // EPERM backoff). Logged with each failed spawn so a Defender-induced storm
 // is reconstructable: activeSpawnCount > 1 means concurrent spawns were
 // racing the AV scan when the failure hit.
-let _activeShellSpawns = 0;
-
-function _isPowerShellSpawn(shell, shellArg) {
-  return /pwsh|powershell/i.test(String(shell || '')) || shellArg === '-Command';
-}
-
 // Windows Defender intermittently fails node→PowerShell spawns with EPERM
 // while it scans the child image (see shell-runtime.mjs Trojan false-positive
 // note). The failure is at spawn() time — before any stdio/side effect — so a
@@ -458,71 +455,6 @@ function _isPowerShellSpawn(shell, shellArg) {
 // Retry ONLY on EPERM/win32/powershell; everything else throws on first
 // failure. Backoff 100/300/700ms caps added latency at ~1.1s. Every failed
 // attempt logs one diagnostic line for later reconstruction.
-async function _spawnShellWithRetry({ shell, argv, spawnOptions, shellArg, cwd }) {
-  const _delays = [100, 300, 700];
-  const _isPowerShell = _isPowerShellSpawn(shell, shellArg);
-  _activeShellSpawns++;
-  try {
-    let attempt = 0;
-    for (;;) {
-      try {
-        const child = spawn(shell, argv, spawnOptions);
-        // spawn() reports ENOENT/EACCES on nextTick. Keep a guard listener
-        // attached from the same synchronous frame as spawn(), and do not
-        // resolve this helper until the child emits `spawn`. The caller adopts
-        // the guard atomically (new listener first, guard removal second), so
-        // there is never an unhandled-error window across either await.
-        let bufferedError = null;
-        const guardError = (err) => { bufferedError = bufferedError || err; };
-        child.on('error', guardError);
-        try {
-          await new Promise((resolveSpawn, rejectSpawn) => {
-            const onSpawn = () => {
-              child.removeListener('error', onError);
-              resolveSpawn();
-            };
-            const onError = (err) => {
-              child.removeListener('spawn', onSpawn);
-              rejectSpawn(err);
-            };
-            child.once('spawn', onSpawn);
-            child.once('error', onError);
-          });
-        } catch (err) {
-          child.removeListener('error', guardError);
-          throw err;
-        }
-        return {
-          child,
-          adoptErrorHandler(handler) {
-            child.on('error', handler);
-            child.removeListener('error', guardError);
-            if (bufferedError) handler(bufferedError);
-          },
-        };
-      } catch (err) {
-        try {
-          console.error('[shell-spawn-retry] ' + JSON.stringify({
-            code: (err && err.code) || null,
-            syscall: (err && err.syscall) || null,
-            shell,
-            cwd,
-            activeSpawnCount: _activeShellSpawns,
-          }));
-        } catch { /* logging must never mask the spawn error */ }
-        const _canRetry = err && err.code === 'EPERM'
-          && process.platform === 'win32'
-          && _isPowerShell
-          && attempt < _delays.length;
-        if (!_canRetry) throw err;
-        await new Promise((r) => setTimeout(r, _delays[attempt++]));
-      }
-    }
-  } finally {
-    _activeShellSpawns--;
-  }
-}
-
 export function execShellCommand({
   shell,
   shellArg,
@@ -537,8 +469,16 @@ export function execShellCommand({
   clientHostPid,
   backgroundOnTimeout,
   promotedTimeoutMs = 0,
+  admission = resourceAdmission,
 }) {
   return new Promise(async (resolve) => {
+    let resultResolved = false;
+    const resolveResult = (result) => {
+      if (resultResolved) return false;
+      resultResolved = true;
+      resolve(result);
+      return true;
+    };
     const taskId = `shell_${randomUUID().slice(0, 8)}`;
     const taskOutput = new TaskOutput(taskId);
     let timedOut = false;
@@ -553,6 +493,49 @@ export function execShellCommand({
     let timer = null;
     let abortHandler = null;
     let partialOutput = false;
+    let resourceLease = null;
+    let resourceLeaseSettlement = null;
+    const releaseResourceLease = async () => {
+      if (!resourceLease) return null;
+      const lease = resourceLease;
+      resourceLease = null;
+      try {
+        await lease.release();
+        return null;
+      } catch (error) {
+        return error;
+      }
+    };
+    const releaseResourceLeaseWhenTreeQuiescent = (pid, { waitForRootExit = false } = {}) => {
+      if (resourceLeaseSettlement) return resourceLeaseSettlement;
+      if (!resourceLease) return { pending: false, promise: Promise.resolve() };
+      const lease = resourceLease;
+      resourceLease = null;
+      const cleanup = Promise.withResolvers();
+      const tracker = trackProcessTreeQuiescence(pid, () => {
+        try {
+          Promise.resolve(lease.release()).then(
+            () => cleanup.resolve({ error: null }),
+            (error) => cleanup.resolve({ error }),
+          );
+        } catch (error) {
+          cleanup.resolve({ error });
+        }
+      }, { waitForRootExit });
+      resourceLeaseSettlement = {
+        lease,
+        tracker,
+        get pending() { return tracker.pending; },
+        promise: cleanup.promise,
+      };
+      return resourceLeaseSettlement;
+    };
+    const detachAbortHandler = () => {
+      if (abortSignal && abortHandler) {
+        try { abortSignal.removeEventListener('abort', abortHandler); } catch {}
+        abortHandler = null;
+      }
+    };
     // MCP live-progress: throttled "running Ns, M lines" emits while the
     // foreground command runs. Inert (never armed) when onProgress is null.
     const _hasProgress = typeof onProgress === 'function';
@@ -568,6 +551,7 @@ export function execShellCommand({
     // the child's lifecycle is owned by the shell-jobs registry. Mutually
     // exclusive with `settled`: whichever transition wins first wins for good.
     let autoBackgrounded = false;
+    let autoBackgroundJobId = null;
     let autoBgTimer = null;
     // Treekill + force-settle deadline. treeKill alone leaves settle()
     // pending on 'close'/'exit'; on Windows a taskkill miss or a grandchild
@@ -597,9 +581,14 @@ export function execShellCommand({
 
     let child;
     try {
+      resourceLease = await admission.acquire('shell', {
+        signal: abortSignal || null,
+        label: String(command || '').slice(0, 120),
+      });
       const _policyErr = await _execPolicyBlockMessage(command);
       if (_policyErr) {
-        resolve(
+        await releaseResourceLease();
+        resolveResult(
           new ExecResult({
             stdout: '',
             stderr: _policyErr,
@@ -655,18 +644,28 @@ export function execShellCommand({
         childGroupPid: child.pid,
         label: 'shell-command',
       });
+      // Windows has no process-group handle. Begin observing while the owned
+      // root still exists so descendants can be proven before root exit.
+      releaseResourceLeaseWhenTreeQuiescent(child.pid, { waitForRootExit: true });
     } catch (err) {
-      resolve(
+      const cleanupError = await releaseResourceLease();
+      const spawnText = String((err && err.message) || err);
+      const cleanupText = cleanupError
+        ? `${spawnText}; resource cleanup failed: ${cleanupError?.message || cleanupError}`
+        : spawnText;
+      resolveResult(
         new ExecResult({
           stdout: '',
-          stderr: String((err && err.message) || err),
+          stderr: cleanupText,
           exitCode: 1,
           signal: null,
           timedOut: false,
           killed: false,
           taskId,
           failurePhase: 'tool',
-          failureReason: 'spawn failed',
+          failureReason: err?.code === 'ERESOURCEPRESSURE' || err?.code === 'ERESOURCEQUEUEFULL'
+            ? 'resource pressure'
+            : 'spawn failed',
         }),
       );
       return;
@@ -712,11 +711,7 @@ export function execShellCommand({
         clearTimeout(autoBgTimer);
         autoBgTimer = null;
       }
-      if (abortSignal && abortHandler) {
-        try {
-          abortSignal.removeEventListener('abort', abortHandler);
-        } catch {}
-      }
+      detachAbortHandler();
       // getStdout/getStderr can throw on a spilled-file read failure (EBADF
       // after unlink race, EACCES). Without this catch the rejection bubbles
       // up and leaves the outer settle promise unresolved, hanging the call.
@@ -741,7 +736,12 @@ export function execShellCommand({
       } else {
         taskOutput.closeFds();
       }
-      resolve(
+      const leaseSettlement = resourceLeaseSettlement
+        || releaseResourceLeaseWhenTreeQuiescent(child.pid);
+      leaseSettlement.tracker?.rootExited?.();
+      await leaseSettlement.tracker?.afterRootExitCheck?.();
+      if (!leaseSettlement.pending) await leaseSettlement.promise;
+      resolveResult(
         new ExecResult({
           stdout,
           stderr,
@@ -863,6 +863,8 @@ export function execShellCommand({
         }
         return;
       }
+      const promotedLease = resourceLeaseSettlement?.lease || resourceLease;
+      child.once('close', () => { resourceLeaseSettlement?.tracker?.rootExited?.(); });
       // Wire the lifecycle: on close, write the exit-code file FIRST then
       // touch donePath STRICTLY AFTER — the exact ordering refreshShellJob()
       // gates completion on (donePath visible ⇒ exit file fully flushed).
@@ -881,6 +883,7 @@ export function execShellCommand({
       try { stderr = await taskOutput.getStderr(); }
       catch (err) { taskOutput.writeError = taskOutput.writeError || err; }
       const jobId = job ? job.jobId : null;
+      autoBackgroundJobId = jobId;
       // Re-check after the awaited capture reads: cancellation can race after
       // adoption commits. Never report that cancelled process as a successful
       // still-running background task.
@@ -889,7 +892,8 @@ export function execShellCommand({
         killCause = 'cancellation';
         try { killShellJob(jobId); } catch {}
         try { treeKill(child); } catch {}
-        resolve(new ExecResult({
+        await promotedLease?.detachDependency?.();
+        resolveResult(new ExecResult({
           stdout,
           stderr,
           exitCode: null,
@@ -908,11 +912,20 @@ export function execShellCommand({
         }));
         return;
       }
+      // Promotion changes a scoped dependency into detached lifetime work.
+      // Re-admit the continuing parent through the normal bounded queue before
+      // returning control; if the child exits first, its close release supplies
+      // the capacity that completes this restoration.
+      await promotedLease?.detachDependency?.();
+      // The adopted job now owns cancellation through task control. Retaining
+      // the foreground caller's signal listener would keep the completed tool
+      // frame alive and could later kill an unrelated, already-returned job.
+      detachAbortHandler();
       const secs = Math.max(0, Math.round((Date.now() - _startMs) / 1000));
       const _verb = reason === 'timeout'
         ? `moved to background at timeout after ${secs}s`
         : `auto-backgrounded after ${secs}s`;
-      resolve(
+      resolveResult(
         new ExecResult({
           stdout,
           stderr,
@@ -936,6 +949,33 @@ export function execShellCommand({
         }),
       );
     };
+    const fireAutoBackground = (options) => {
+      void _autoBackground(options).catch((error) => {
+        if (resultResolved) return;
+        settled = true;
+        autoBackgrounded = true;
+        killed = true;
+        killCause = 'resource-cleanup-error';
+        detachAbortHandler();
+        try { if (autoBackgroundJobId) killShellJob(autoBackgroundJobId); } catch {}
+        try { treeKill(child); } catch {}
+        resolveResult(new ExecResult({
+          stdout: '',
+          stderr: `resource cleanup failed during background promotion: ${error?.message || error}`,
+          exitCode: 1,
+          signal: child?.signalCode || null,
+          timedOut: false,
+          killed: true,
+          killCause,
+          taskId,
+          partialOutput: true,
+          outputCaptureError: taskOutput.writeError,
+          failurePhase: 'tool',
+          failureReason: 'resource cleanup failed',
+          backgrounded: false,
+        }));
+      });
+    };
 
     if (timeoutMs > 0) {
       timer = setTimeout(() => {
@@ -953,7 +993,7 @@ export function execShellCommand({
           child.exitCode == null &&
           child.signalCode == null
         ) {
-          _autoBackground({ reason: 'timeout' });
+          fireAutoBackground({ reason: 'timeout' });
           return;
         }
         timedOut = true;
@@ -985,7 +1025,7 @@ export function execShellCommand({
       !_isBackground &&
       (timeoutMs <= 0 || autoBackgroundMs < timeoutMs)
     ) {
-      autoBgTimer = setTimeout(() => { _autoBackground(); }, autoBackgroundMs);
+      autoBgTimer = setTimeout(() => { fireAutoBackground(); }, autoBackgroundMs);
       if (autoBgTimer.unref) autoBgTimer.unref();
     }
 

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

@@ -31,7 +31,7 @@ async function connectInner(self) {
     self.client = null;
     throw err;
   }
-  self.persistAccessFromMainChannel();
+  await self.persistAccessFromMainChannel();
 }
 
 async function buildClient(self) {

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

@@ -18,7 +18,7 @@ import { join, sep } from "path";
 import { createHash } from "crypto";
 import { chunk, formatForDiscord, MAX_DISCORD_MESSAGE } from "../lib/format.mjs";
 import { withConfigLock } from "../lib/config-lock.mjs";
-import { readSection, updateSection } from "../../shared/config.mjs";
+import { readSection, updateSectionAsync } from "../../shared/config.mjs";
 import { normalizeAccess, safeAttName } from "./discord-access.mjs";
 import { MAX_ATTACHMENT_BYTES, downloadSingleAttachment } from "./discord-attachments.mjs";
 import * as gateway from "./discord-gateway.mjs";
@@ -473,7 +473,7 @@ class DiscordBackend {
       return this.initialAccess;
     }
   }
-  persistAccessFromMainChannel() {
+  async persistAccessFromMainChannel() {
     if (this.isStatic || !this.configFile) return;
     try {
       const id = this.mainChannelId;
@@ -482,7 +482,7 @@ class DiscordBackend {
       const access = normalizeAccess(parsed.access);
       if (!(id in access.channels)) {
         access.channels[id] = { requireMention: false, allowFrom: [] };
-        this.saveAccess(access);
+        await this.saveAccess(access);
       }
     } catch (err) {
       process.stderr.write(`mixdog discord: persistAccessFromMainChannel failed: ${err}\n`);
@@ -499,10 +499,10 @@ class DiscordBackend {
     }
     return a;
   }
-  saveAccess(a) {
+  async saveAccess(a) {
     if (this.isStatic) return;
     if (!this.configFile) return;
-    return withConfigLock(() => {
+    return withConfigLock(async () => {
       mkdirSync(this.stateDir, { recursive: true, mode: 448 });
       const access = {
         dmPolicy: a.dmPolicy,
@@ -513,7 +513,7 @@ class DiscordBackend {
         ...a.replyToMode ? { replyToMode: a.replyToMode } : {},
         ...a.textChunkLimit ? { textChunkLimit: a.textChunkLimit } : {}
       };
-      updateSection("channels", (channels) => ({
+      await updateSectionAsync("channels", (channels) => ({
         ...channels,
         access
       }));

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

@@ -2,7 +2,16 @@ import { readFileSync, mkdirSync } from "fs";
 import { join } from "path";
 import { DiscordBackend } from "../backends/discord.mjs";
 import { TelegramBackend } from "../backends/telegram.mjs";
-import { readSection, updateSection, CONFIG_PATH as MIXDOG_CONFIG_PATH, getDiscordToken, getTelegramToken, diagnoseDiscordTokenValue } from "../../shared/config.mjs";
+import {
+  readSection,
+  updateSection,
+  CONFIG_PATH as MIXDOG_CONFIG_PATH,
+  SECRET_ACCOUNTS,
+  getDiscordToken,
+  getTelegramToken,
+  diagnoseDiscordTokenValue,
+  invalidateSecretReadCache,
+} from "../../shared/config.mjs";
 import { listSchedules } from "../../shared/schedules-db.mjs";
 import { resolvePluginData } from "../../shared/plugin-paths.mjs";
 const DATA_DIR = resolvePluginData();
@@ -46,8 +55,12 @@ function resolveChannelId(raw = {}, backend = "discord") {
   return "";
 }
 
-async function loadConfig() {
+async function loadConfig({ freshSecrets = false } = {}) {
   try {
+    if (freshSecrets) {
+      invalidateSecretReadCache(SECRET_ACCOUNTS.discordToken);
+      invalidateSecretReadCache(SECRET_ACCOUNTS.telegramToken);
+    }
     let raw = readSection("channels");
     raw = raw && typeof raw === "object" ? raw : {};
     // Schedules are the PG `scheduler.schedules` table (single source of

package/src/runtime/channels/lib/memory-client.mjs

@@ -218,6 +218,16 @@ function atomicWrite(targetPath, contents) {
 // site, so no drain/replay format or TTL semantics change.
 const _dedupeIndex = new Map()
 let _dedupeIndexSeeded = false
+function dropDedupeIndexForPath(bufferPath) {
+  for (const [key, indexedPath] of _dedupeIndex) {
+    if (indexedPath === bufferPath) _dedupeIndex.delete(key)
+  }
+}
+function replaceDedupeIndexPath(previousPath, nextPath) {
+  for (const [key, indexedPath] of _dedupeIndex) {
+    if (indexedPath === previousPath) _dedupeIndex.set(key, nextPath)
+  }
+}
 function seedDedupeIndex(kind) {
   if (_dedupeIndexSeeded) return
   _dedupeIndexSeeded = true
@@ -266,9 +276,11 @@ function bufferToDisk(kind, payload, { dedupeKey = null } = {}) {
 // leaves the file in place and returns false so the caller skips it this pass.
 function moveToDead(name, reason) {
   process.stderr.write(`[memory-client] quarantining ${name} to dead/ (${reason})\n`)
+  const bufferPath = path.join(BUFFER_DIR, name)
   try {
     fs.mkdirSync(DEAD_DIR, { recursive: true })
-    fs.renameSync(path.join(BUFFER_DIR, name), path.join(DEAD_DIR, name))
+    fs.renameSync(bufferPath, path.join(DEAD_DIR, name))
+    dropDedupeIndexForPath(bufferPath)
     return true
   } catch (e) {
     process.stderr.write(`[memory-client] quarantine of ${name} failed (${e.message}) — leaving in place\n`)
@@ -355,7 +367,10 @@ export async function drainBuffer() {
         // throwOnError: non-2xx status or an {error} body REJECTS, so the
         // file is kept/aged for retry instead of unlinked (HIGH: data loss).
         await memoryFetch('POST', endpoint, payload, 10_000, { throwOnError: true })
-        try { fs.unlinkSync(bufferPath) } catch {}
+        try {
+          fs.unlinkSync(bufferPath)
+          dropDedupeIndexForPath(bufferPath)
+        } catch {}
         drained++
       } catch (e) {
         const attempts = parseRetry(name) + 1
@@ -375,7 +390,9 @@ export async function drainBuffer() {
           // THIS pass so it can't block the oldest-first queue forever — the
           // next drain re-reads its (unchanged) .rN and retries.
           try {
-            fs.renameSync(bufferPath, path.join(BUFFER_DIR, retryName(name, attempts)))
+            const nextPath = path.join(BUFFER_DIR, retryName(name, attempts))
+            fs.renameSync(bufferPath, nextPath)
+            replaceDedupeIndexPath(bufferPath, nextPath)
           } catch {
             // Rename lock/EPERM: don't break the whole pass on a file we
             // couldn't even age — skip it and CONTINUE so later buffered

package/src/runtime/channels/lib/owned-runtime.mjs

@@ -410,7 +410,9 @@ async function refreshBridgeOwnership(options = {}) {
 async function reloadRuntimeConfig() {
   const previousBackend = getBackend();
   const previousBackendName = previousBackend?.name || "";
-  setConfig(await loadConfig());
+  // File-watch/tool-triggered reloads must bypass the short keychain hit cache:
+  // another process may have just saved or rotated the channel credential.
+  setConfig(await loadConfig({ freshSecrets: true }));
   scheduler.reloadConfig(
     getConfig().nonInteractive ?? [],
     getConfig().interactive ?? [],
@@ -419,7 +421,10 @@ async function reloadRuntimeConfig() {
     { restart: getBridgeRuntimeConnected() }
   );
   const nextBackend = createBackend(getConfig());
-  const backendChanged = (nextBackend?.name || "") !== previousBackendName;
+  const backendTypeChanged = (nextBackend?.name || "") !== previousBackendName;
+  const credentialsChanged = !backendTypeChanged
+    && String(nextBackend?.token || "") !== String(previousBackend?.token || "");
+  const backendChanged = backendTypeChanged || credentialsChanged;
   if (backendChanged) {
     const shouldRestart = getBridgeRuntimeConnected() || bridgeRuntimeStarting;
     if (shouldRestart) await stopOwnedRuntime("getBackend() getConfig() changed");
@@ -439,19 +444,21 @@ async function reloadRuntimeConfig() {
     // backendChanged — same-getBackend() reloads keep their binding untouched.
     // (active-instance is cleared by stopOwnedRuntime on the restart path; we
     // don't re-advertise here to avoid resurrecting a just-cleared entry.)
-    try { forwarder.stopWatch(); } catch {}
-    forwarder.channelId = "";
-    forwarder.transcriptPath = "";
-    try {
-      statusState.update((state) => {
-        state.channelId = "";
-        state.transcriptPath = "";
-      });
-    } catch {}
+    if (backendTypeChanged) {
+      try { forwarder.stopWatch(); } catch {}
+      forwarder.channelId = "";
+      forwarder.transcriptPath = "";
+      try {
+        statusState.update((state) => {
+          state.channelId = "";
+          state.transcriptPath = "";
+        });
+      } catch {}
+    }
     // stopOwnedRuntime above tore the owned runtime down; a same-session reload
     // reconnects the NEW backend here. The in-flight start (if any) has already
     // settled above, so this start is not dropped by the in-flight guard.
-    if (shouldRestart) refreshBridgeOwnershipSafe({ restoreBinding: false });
+    if (shouldRestart) refreshBridgeOwnershipSafe({ restoreBinding: !backendTypeChanged });
   } else if (nextBackend !== previousBackend) {
     try { await nextBackend.disconnect?.(); } catch {}
   }

package/src/runtime/channels/lib/status-snapshot.mjs

@@ -35,6 +35,7 @@ function stableSnapshotJson(snapshot) {
 // Key: channelId  Value: { label, latestSeenId, unseenCount }
 // No persistence across restarts — clean start is fine for v1.
 const _discordUnread = new Map();
+const DISCORD_UNREAD_MAX_CHANNELS = 500;
 
 /**
  * Called whenever the backend observes messages for a channelId.
@@ -63,6 +64,14 @@ export function recordFetchedMessages(channelId, channelLabel, messages, options
   }
   // First call: zero unread (baseline, not retroactive).
 
+  // Retain the most recently observed channels only. Channel ids originate from
+  // inbound traffic and ad-hoc fetches, so an unbounded process-wide registry
+  // would otherwise grow for the worker lifetime.
+  if (_discordUnread.has(channelId)) {
+    _discordUnread.delete(channelId);
+  } else if (_discordUnread.size >= DISCORD_UNREAD_MAX_CHANNELS) {
+    _discordUnread.delete(_discordUnread.keys().next().value);
+  }
   _discordUnread.set(channelId, {
     label: channelLabel ?? channelId,
     latestSeenId: newLatestId,

package/src/runtime/channels/lib/tool-dispatch.mjs

@@ -82,14 +82,18 @@ function createToolDispatch({
           }
         case "reload_config": {
             await reloadRuntimeConfig();
-            // Extend reload to the agent module so providers/presets/maintenance
-            // hot-reload on the same call (dynamic import: agent/index.mjs does not
-            // import channels, so this stays acyclic and tolerant of load order).
+            // Extend reload to the refactored agent runtime so providers/presets/
+            // maintenance hot-reload on the same call.
             let agentReloadMsg = "";
             if (process.env.MIXDOG_STANDALONE !== '1') {
               try {
-                const { reloadAgentConfig } = await import("../../agent/index.mjs");
-                await reloadAgentConfig("reload_config tool");
+                const [{ loadConfig }, { initProviders, refreshCatalogs }] = await Promise.all([
+                  import("../../agent/orchestrator/config.mjs"),
+                  import("../../agent/orchestrator/providers/registry.mjs"),
+                ]);
+                const agentConfig = loadConfig();
+                await initProviders(agentConfig.providers || {});
+                await refreshCatalogs();
                 agentReloadMsg = ", agent providers/presets/maintenance";
               } catch (err) {
                 process.stderr.write(`[reload_config] agent reload failed: ${err?.message || String(err)}\n`);

package/src/runtime/channels/lib/worker-main.mjs

@@ -461,7 +461,19 @@ function wireWebhookHandlers() {
     // final event is forwarded to the Lead via the same channel-notify
     // path used by schedule & event-queue (injectAndRecord). Silent
     // lifecycle pings keep routing only to Discord.
-    const agentMod = await import("../../agent/index.mjs");
+    const [{ createStandaloneAgent }, cfgMod, reg, mgr] = await Promise.all([
+      import("../../../standalone/agent-tool.mjs"),
+      import("../../agent/orchestrator/config.mjs"),
+      import("../../agent/orchestrator/providers/registry.mjs"),
+      import("../../agent/orchestrator/session/manager.mjs"),
+    ]);
+    const agentTool = createStandaloneAgent({
+      cfgMod,
+      reg,
+      mgr,
+      dataDir: cfgMod.getPluginData(),
+      cwd,
+    });
     const channelId = resolveWebhookChannelId(context?.channel);
     const endpoint = context?.endpoint || "unknown";
     const event = context?.event || null;
@@ -508,10 +520,9 @@ function wireWebhookHandlers() {
     // Falls back to the session entry position; never the plugin CACHE root.
     const ownerPid = getActiveOwnerPid(readActiveInstance());
     const ownerCwd = (ownerPid && readLastSessionCwd(ownerPid)) || captureOriginalUserCwd();
-    return agentMod.handleToolCall(
-      "bridge",
-      { role, preset, prompt, cwd: cwd || ownerCwd },
-      { notifyFn },
+    return agentTool.execute(
+      { type: "spawn", agent: role, preset, prompt, cwd: cwd || ownerCwd },
+      { callerCwd: cwd || ownerCwd, invocationSource: "webhook", notifyFn },
     );
   });
 }