@femtomc/mu-server 26.2.68 → 26.2.70

package/dist/control_plane.js

@@ -1,7 +1,9 @@
-import { ApprovedCommandBroker, CommandContextResolver, MessagingOperatorRuntime, operatorExtensionPaths, PiMessagingOperatorBackend, } from "@femtomc/mu-agent";
-import { ControlPlaneCommandPipeline, ControlPlaneOutbox, ControlPlaneOutboxDispatcher, ControlPlaneRuntime, correlationFromCommandRecord, DiscordControlPlaneAdapter, getControlPlanePaths, SlackControlPlaneAdapter, TelegramControlPlaneAdapter, TelegramControlPlaneAdapterSpec, } from "@femtomc/mu-control-plane";
+import { ControlPlaneCommandPipeline, ControlPlaneOutbox, ControlPlaneRuntime, DiscordControlPlaneAdapter, getControlPlanePaths, SlackControlPlaneAdapter, TelegramControlPlaneAdapterSpec, } from "@femtomc/mu-control-plane";
 import { DEFAULT_MU_CONFIG } from "./config.js";
 import { ControlPlaneRunSupervisor, } from "./run_supervisor.js";
+import { buildMessagingOperatorRuntime, createOutboxDrainLoop, } from "./control_plane_bootstrap_helpers.js";
+import { enqueueRunEventOutbox } from "./control_plane_run_outbox.js";
+import { TelegramAdapterGenerationManager } from "./control_plane_telegram_generation.js";
 function generationTags(generation, component) {
     return {
         generation_id: generation.generation_id,
@@ -31,577 +33,6 @@ export function detectAdapters(config) {
     }
     return adapters;
 }
-const TELEGRAM_GENERATION_SUPERVISOR_ID = "telegram-adapter";
-const TELEGRAM_WARMUP_TIMEOUT_MS = 2_000;
-const TELEGRAM_DRAIN_TIMEOUT_MS = 5_000;
-function cloneControlPlaneConfig(config) {
-    return JSON.parse(JSON.stringify(config));
-}
-function controlPlaneNonTelegramFingerprint(config) {
-    return JSON.stringify({
-        adapters: {
-            slack: config.adapters.slack,
-            discord: config.adapters.discord,
-            gmail: config.adapters.gmail,
-        },
-        operator: config.operator,
-    });
-}
-function telegramAdapterConfigFromControlPlane(config) {
-    const webhookSecret = config.adapters.telegram.webhook_secret;
-    if (!webhookSecret) {
-        return null;
-    }
-    return {
-        webhookSecret,
-        botToken: config.adapters.telegram.bot_token,
-        botUsername: config.adapters.telegram.bot_username,
-    };
-}
-function applyTelegramAdapterConfig(base, telegram) {
-    const next = cloneControlPlaneConfig(base);
-    next.adapters.telegram.webhook_secret = telegram?.webhookSecret ?? null;
-    next.adapters.telegram.bot_token = telegram?.botToken ?? null;
-    next.adapters.telegram.bot_username = telegram?.botUsername ?? null;
-    return next;
-}
-function cloneTelegramAdapterConfig(config) {
-    return {
-        webhookSecret: config.webhookSecret,
-        botToken: config.botToken,
-        botUsername: config.botUsername,
-    };
-}
-function describeError(err) {
-    if (err instanceof Error && err.message.trim().length > 0) {
-        return err.message;
-    }
-    return String(err);
-}
-async function runWithTimeout(opts) {
-    if (opts.timeoutMs <= 0) {
-        return await opts.run();
-    }
-    return await new Promise((resolve, reject) => {
-        let settled = false;
-        const timer = setTimeout(() => {
-            if (settled) {
-                return;
-            }
-            settled = true;
-            reject(new Error(opts.timeoutMessage));
-        }, opts.timeoutMs);
-        void opts
-            .run()
-            .then((value) => {
-            if (settled) {
-                return;
-            }
-            settled = true;
-            clearTimeout(timer);
-            resolve(value);
-        })
-            .catch((err) => {
-            if (settled) {
-                return;
-            }
-            settled = true;
-            clearTimeout(timer);
-            reject(err);
-        });
-    });
-}
-class TelegramAdapterGenerationManager {
-    #pipeline;
-    #outbox;
-    #nowMs;
-    #onOutboxEnqueued;
-    #signalObserver;
-    #hooks;
-    #generationSeq = -1;
-    #active = null;
-    #previousConfig = null;
-    #activeControlPlaneConfig;
-    constructor(opts) {
-        this.#pipeline = opts.pipeline;
-        this.#outbox = opts.outbox;
-        this.#nowMs = opts.nowMs ?? Date.now;
-        this.#onOutboxEnqueued = opts.onOutboxEnqueued ?? null;
-        this.#signalObserver = opts.signalObserver ?? null;
-        this.#hooks = opts.hooks ?? null;
-        this.#activeControlPlaneConfig = cloneControlPlaneConfig(opts.initialConfig);
-    }
-    #nextGeneration() {
-        const nextSeq = this.#generationSeq + 1;
-        return {
-            generation_id: `${TELEGRAM_GENERATION_SUPERVISOR_ID}-gen-${nextSeq}`,
-            generation_seq: nextSeq,
-        };
-    }
-    #buildAdapter(config, opts) {
-        return new TelegramControlPlaneAdapter({
-            pipeline: this.#pipeline,
-            outbox: this.#outbox,
-            webhookSecret: config.webhookSecret,
-            botUsername: config.botUsername,
-            deferredIngress: true,
-            onOutboxEnqueued: this.#onOutboxEnqueued ?? undefined,
-            signalObserver: this.#signalObserver ?? undefined,
-            acceptIngress: opts.acceptIngress,
-            ingressDrainEnabled: opts.ingressDrainEnabled,
-            nowMs: this.#nowMs,
-        });
-    }
-    async initialize() {
-        const initial = telegramAdapterConfigFromControlPlane(this.#activeControlPlaneConfig);
-        if (!initial) {
-            return;
-        }
-        const generation = this.#nextGeneration();
-        const adapter = this.#buildAdapter(initial, {
-            acceptIngress: true,
-            ingressDrainEnabled: true,
-        });
-        await adapter.warmup();
-        const health = await adapter.healthCheck();
-        if (!health.ok) {
-            await adapter.stop({ force: true, reason: "startup_health_gate_failed" });
-            throw new Error(`telegram adapter warmup health failed: ${health.reason}`);
-        }
-        this.#active = {
-            generation,
-            config: cloneTelegramAdapterConfig(initial),
-            adapter,
-        };
-        this.#generationSeq = generation.generation_seq;
-    }
-    hasActiveGeneration() {
-        return this.#active != null;
-    }
-    activeGeneration() {
-        return this.#active ? { ...this.#active.generation } : null;
-    }
-    activeBotToken() {
-        return this.#active?.config.botToken ?? null;
-    }
-    activeAdapter() {
-        return this.#active?.adapter ?? null;
-    }
-    canHandleConfig(nextConfig, reason) {
-        if (reason === "rollback") {
-            return true;
-        }
-        return (controlPlaneNonTelegramFingerprint(nextConfig) ===
-            controlPlaneNonTelegramFingerprint(this.#activeControlPlaneConfig));
-    }
-    async #rollbackToPrevious(opts) {
-        if (!opts.previous) {
-            return { ok: false, error: "rollback_unavailable" };
-        }
-        try {
-            opts.previous.adapter.activateIngress();
-            this.#active = opts.previous;
-            this.#previousConfig = cloneTelegramAdapterConfig(opts.failedRecord.config);
-            await opts.failedRecord.adapter.stop({ force: true, reason: `rollback:${opts.reason}` });
-            this.#activeControlPlaneConfig = applyTelegramAdapterConfig(this.#activeControlPlaneConfig, opts.previous.config);
-            return { ok: true };
-        }
-        catch (err) {
-            return { ok: false, error: describeError(err) };
-        }
-    }
-    async reload(opts) {
-        if (!this.canHandleConfig(opts.config, opts.reason)) {
-            return {
-                handled: false,
-                ok: false,
-                reason: opts.reason,
-                route: "/webhooks/telegram",
-                from_generation: this.#active?.generation ?? null,
-                to_generation: null,
-                active_generation: this.#active?.generation ?? null,
-                warmup: null,
-                cutover: null,
-                drain: null,
-                rollback: {
-                    requested: opts.reason === "rollback",
-                    trigger: null,
-                    attempted: false,
-                    ok: true,
-                },
-            };
-        }
-        const rollbackRequested = opts.reason === "rollback";
-        let rollbackTrigger = rollbackRequested ? "manual" : null;
-        let rollbackAttempted = false;
-        let rollbackOk = true;
-        let rollbackError;
-        const fromGeneration = this.#active?.generation ?? null;
-        const previousRecord = this.#active;
-        const warmupTimeoutMs = Math.max(0, Math.trunc(opts.warmupTimeoutMs ?? TELEGRAM_WARMUP_TIMEOUT_MS));
-        const drainTimeoutMs = Math.max(0, Math.trunc(opts.drainTimeoutMs ?? TELEGRAM_DRAIN_TIMEOUT_MS));
-        const targetConfig = rollbackRequested
-            ? this.#previousConfig
-            : telegramAdapterConfigFromControlPlane(opts.config);
-        if (rollbackRequested && !targetConfig) {
-            return {
-                handled: true,
-                ok: false,
-                reason: opts.reason,
-                route: "/webhooks/telegram",
-                from_generation: fromGeneration,
-                to_generation: null,
-                active_generation: fromGeneration,
-                warmup: null,
-                cutover: null,
-                drain: null,
-                rollback: {
-                    requested: true,
-                    trigger: "rollback_unavailable",
-                    attempted: false,
-                    ok: false,
-                    error: "rollback_unavailable",
-                },
-                error: "rollback_unavailable",
-            };
-        }
-        if (!targetConfig && !previousRecord) {
-            this.#activeControlPlaneConfig = cloneControlPlaneConfig(opts.config);
-            return {
-                handled: true,
-                ok: true,
-                reason: opts.reason,
-                route: "/webhooks/telegram",
-                from_generation: null,
-                to_generation: null,
-                active_generation: null,
-                warmup: null,
-                cutover: null,
-                drain: null,
-                rollback: {
-                    requested: rollbackRequested,
-                    trigger: rollbackTrigger,
-                    attempted: false,
-                    ok: true,
-                },
-            };
-        }
-        if (!targetConfig && previousRecord) {
-            const drainStartedAtMs = Math.trunc(this.#nowMs());
-            let forcedStop = false;
-            let drainError;
-            let drainTimedOut = false;
-            try {
-                previousRecord.adapter.beginDrain();
-                if (this.#hooks?.onDrain) {
-                    await this.#hooks.onDrain({
-                        generation: previousRecord.generation,
-                        reason: opts.reason,
-                        timeout_ms: drainTimeoutMs,
-                    });
-                }
-                const drain = await runWithTimeout({
-                    timeoutMs: drainTimeoutMs,
-                    timeoutMessage: "telegram_drain_timeout",
-                    run: async () => await previousRecord.adapter.drain({ timeoutMs: drainTimeoutMs, reason: opts.reason }),
-                });
-                drainTimedOut = drain.timed_out;
-                if (!drain.ok || drain.timed_out) {
-                    forcedStop = true;
-                    await previousRecord.adapter.stop({ force: true, reason: "disable_drain_timeout" });
-                }
-                else {
-                    await previousRecord.adapter.stop({ force: false, reason: "disable" });
-                }
-            }
-            catch (err) {
-                drainError = describeError(err);
-                forcedStop = true;
-                drainTimedOut = drainError.includes("timeout");
-                await previousRecord.adapter.stop({ force: true, reason: "disable_drain_failed" });
-            }
-            this.#previousConfig = cloneTelegramAdapterConfig(previousRecord.config);
-            this.#active = null;
-            this.#activeControlPlaneConfig = applyTelegramAdapterConfig(this.#activeControlPlaneConfig, null);
-            return {
-                handled: true,
-                ok: drainError == null,
-                reason: opts.reason,
-                route: "/webhooks/telegram",
-                from_generation: fromGeneration,
-                to_generation: null,
-                active_generation: null,
-                warmup: null,
-                cutover: {
-                    ok: true,
-                    elapsed_ms: 0,
-                },
-                drain: {
-                    ok: drainError == null && !drainTimedOut,
-                    elapsed_ms: Math.max(0, Math.trunc(this.#nowMs()) - drainStartedAtMs),
-                    timed_out: drainTimedOut,
-                    forced_stop: forcedStop,
-                    ...(drainError ? { error: drainError } : {}),
-                },
-                rollback: {
-                    requested: rollbackRequested,
-                    trigger: rollbackTrigger,
-                    attempted: false,
-                    ok: true,
-                },
-                ...(drainError ? { error: drainError } : {}),
-            };
-        }
-        const nextConfig = cloneTelegramAdapterConfig(targetConfig);
-        const toGeneration = this.#nextGeneration();
-        const nextAdapter = this.#buildAdapter(nextConfig, {
-            acceptIngress: false,
-            ingressDrainEnabled: false,
-        });
-        const nextRecord = {
-            generation: toGeneration,
-            config: nextConfig,
-            adapter: nextAdapter,
-        };
-        const warmupStartedAtMs = Math.trunc(this.#nowMs());
-        try {
-            if (this.#hooks?.onWarmup) {
-                await this.#hooks.onWarmup({ generation: toGeneration, reason: opts.reason });
-            }
-            await runWithTimeout({
-                timeoutMs: warmupTimeoutMs,
-                timeoutMessage: "telegram_warmup_timeout",
-                run: async () => {
-                    await nextAdapter.warmup();
-                    const health = await nextAdapter.healthCheck();
-                    if (!health.ok) {
-                        throw new Error(`telegram_health_gate_failed:${health.reason}`);
-                    }
-                },
-            });
-        }
-        catch (err) {
-            const error = describeError(err);
-            rollbackTrigger = error.includes("health_gate") ? "health_gate_failed" : "warmup_failed";
-            await nextAdapter.stop({ force: true, reason: "warmup_failed" });
-            return {
-                handled: true,
-                ok: false,
-                reason: opts.reason,
-                route: "/webhooks/telegram",
-                from_generation: fromGeneration,
-                to_generation: toGeneration,
-                active_generation: fromGeneration,
-                warmup: {
-                    ok: false,
-                    elapsed_ms: Math.max(0, Math.trunc(this.#nowMs()) - warmupStartedAtMs),
-                    error,
-                },
-                cutover: null,
-                drain: null,
-                rollback: {
-                    requested: rollbackRequested,
-                    trigger: rollbackTrigger,
-                    attempted: false,
-                    ok: true,
-                },
-                error,
-            };
-        }
-        const cutoverStartedAtMs = Math.trunc(this.#nowMs());
-        try {
-            if (this.#hooks?.onCutover) {
-                await this.#hooks.onCutover({
-                    from_generation: fromGeneration,
-                    to_generation: toGeneration,
-                    reason: opts.reason,
-                });
-            }
-            nextAdapter.activateIngress();
-            if (previousRecord) {
-                previousRecord.adapter.beginDrain();
-            }
-            this.#active = nextRecord;
-            this.#generationSeq = toGeneration.generation_seq;
-            const postCutoverHealth = await nextAdapter.healthCheck();
-            if (!postCutoverHealth.ok) {
-                throw new Error(`telegram_post_cutover_health_failed:${postCutoverHealth.reason}`);
-            }
-        }
-        catch (err) {
-            const error = describeError(err);
-            rollbackTrigger = error.includes("post_cutover") ? "post_cutover_health_failed" : "cutover_failed";
-            rollbackAttempted = true;
-            const rollback = await this.#rollbackToPrevious({
-                failedRecord: nextRecord,
-                previous: previousRecord,
-                reason: opts.reason,
-            });
-            rollbackOk = rollback.ok;
-            rollbackError = rollback.error;
-            if (!rollback.ok) {
-                await nextAdapter.stop({ force: true, reason: "rollback_failed" });
-                this.#active = previousRecord ?? null;
-                this.#activeControlPlaneConfig = applyTelegramAdapterConfig(this.#activeControlPlaneConfig, previousRecord?.config ?? null);
-            }
-            return {
-                handled: true,
-                ok: false,
-                reason: opts.reason,
-                route: "/webhooks/telegram",
-                from_generation: fromGeneration,
-                to_generation: toGeneration,
-                active_generation: this.#active?.generation ?? fromGeneration,
-                warmup: {
-                    ok: true,
-                    elapsed_ms: Math.max(0, cutoverStartedAtMs - warmupStartedAtMs),
-                },
-                cutover: {
-                    ok: false,
-                    elapsed_ms: Math.max(0, Math.trunc(this.#nowMs()) - cutoverStartedAtMs),
-                    error,
-                },
-                drain: null,
-                rollback: {
-                    requested: rollbackRequested,
-                    trigger: rollbackTrigger,
-                    attempted: rollbackAttempted,
-                    ok: rollbackOk,
-                    ...(rollbackError ? { error: rollbackError } : {}),
-                },
-                error,
-            };
-        }
-        let drain = null;
-        if (previousRecord) {
-            const drainStartedAtMs = Math.trunc(this.#nowMs());
-            let forcedStop = false;
-            let drainTimedOut = false;
-            let drainError;
-            try {
-                if (this.#hooks?.onDrain) {
-                    await this.#hooks.onDrain({
-                        generation: previousRecord.generation,
-                        reason: opts.reason,
-                        timeout_ms: drainTimeoutMs,
-                    });
-                }
-                const drained = await runWithTimeout({
-                    timeoutMs: drainTimeoutMs,
-                    timeoutMessage: "telegram_drain_timeout",
-                    run: async () => await previousRecord.adapter.drain({ timeoutMs: drainTimeoutMs, reason: opts.reason }),
-                });
-                drainTimedOut = drained.timed_out;
-                if (!drained.ok || drained.timed_out) {
-                    forcedStop = true;
-                    await previousRecord.adapter.stop({ force: true, reason: "generation_drain_timeout" });
-                }
-                else {
-                    await previousRecord.adapter.stop({ force: false, reason: "generation_drained" });
-                }
-            }
-            catch (err) {
-                drainError = describeError(err);
-                forcedStop = true;
-                drainTimedOut = drainError.includes("timeout");
-                await previousRecord.adapter.stop({ force: true, reason: "generation_drain_failed" });
-            }
-            drain = {
-                ok: drainError == null && !drainTimedOut,
-                elapsed_ms: Math.max(0, Math.trunc(this.#nowMs()) - drainStartedAtMs),
-                timed_out: drainTimedOut,
-                forced_stop: forcedStop,
-                ...(drainError ? { error: drainError } : {}),
-            };
-        }
-        this.#previousConfig = previousRecord ? cloneTelegramAdapterConfig(previousRecord.config) : this.#previousConfig;
-        this.#activeControlPlaneConfig = applyTelegramAdapterConfig(this.#activeControlPlaneConfig, nextConfig);
-        return {
-            handled: true,
-            ok: true,
-            reason: opts.reason,
-            route: "/webhooks/telegram",
-            from_generation: fromGeneration,
-            to_generation: toGeneration,
-            active_generation: toGeneration,
-            warmup: {
-                ok: true,
-                elapsed_ms: Math.max(0, cutoverStartedAtMs - warmupStartedAtMs),
-            },
-            cutover: {
-                ok: true,
-                elapsed_ms: Math.max(0, Math.trunc(this.#nowMs()) - cutoverStartedAtMs),
-            },
-            drain,
-            rollback: {
-                requested: rollbackRequested,
-                trigger: rollbackTrigger,
-                attempted: rollbackAttempted,
-                ok: rollbackOk,
-                ...(rollbackError ? { error: rollbackError } : {}),
-            },
-        };
-    }
-    async stop() {
-        const active = this.#active;
-        this.#active = null;
-        if (!active) {
-            return;
-        }
-        await active.adapter.stop({ force: true, reason: "shutdown" });
-    }
-}
-function sha256Hex(input) {
-    const hasher = new Bun.CryptoHasher("sha256");
-    hasher.update(input);
-    return hasher.digest("hex");
-}
-function outboxKindForRunEvent(kind) {
-    switch (kind) {
-        case "run_completed":
-            return "result";
-        case "run_failed":
-            return "error";
-        default:
-            return "lifecycle";
-    }
-}
-async function enqueueRunEventOutbox(opts) {
-    const command = opts.event.command;
-    if (!command) {
-        return null;
-    }
-    const baseCorrelation = correlationFromCommandRecord(command);
-    const correlation = {
-        ...baseCorrelation,
-        run_root_id: opts.event.run.root_issue_id ?? baseCorrelation.run_root_id,
-    };
-    const envelope = {
-        v: 1,
-        ts_ms: opts.nowMs,
-        channel: command.channel,
-        channel_tenant_id: command.channel_tenant_id,
-        channel_conversation_id: command.channel_conversation_id,
-        request_id: command.request_id,
-        response_id: `resp-${sha256Hex(`run-event:${opts.event.run.job_id}:${opts.event.seq}:${opts.nowMs}`).slice(0, 20)}`,
-        kind: outboxKindForRunEvent(opts.event.kind),
-        body: opts.event.message,
-        correlation,
-        metadata: {
-            async_run: true,
-            run_event_kind: opts.event.kind,
-            run_event_seq: opts.event.seq,
-            run: opts.event.run,
-        },
-    };
-    const decision = await opts.outbox.enqueue({
-        dedupeKey: `run-event:${opts.event.run.job_id}:${opts.event.seq}`,
-        envelope,
-        nowMs: opts.nowMs,
-        maxAttempts: 6,
-    });
-    return decision.record;
-}
 /**
  * Telegram supports a markdown dialect that uses single markers for emphasis.
  * Normalize the most common LLM/GitHub-style markers (`**bold**`, `__italic__`, headings)
@@ -664,26 +95,6 @@ async function postTelegramMessage(botToken, payload) {
         body: JSON.stringify(payload),
     });
 }
-const OUTBOX_DRAIN_INTERVAL_MS = 500;
-function buildMessagingOperatorRuntime(opts) {
-    if (!opts.config.operator.enabled) {
-        return null;
-    }
-    const backend = opts.backend ??
-        new PiMessagingOperatorBackend({
-            provider: opts.config.operator.provider ?? undefined,
-            model: opts.config.operator.model ?? undefined,
-            extensionPaths: operatorExtensionPaths,
-        });
-    return new MessagingOperatorRuntime({
-        backend,
-        broker: new ApprovedCommandBroker({
-            runTriggersEnabled: opts.config.operator.run_triggers_enabled,
-            contextResolver: new CommandContextResolver({ allowedRepoRoots: [opts.repoRoot] }),
-        }),
-        enabled: true,
-    });
-}
 export async function bootstrapControlPlane(opts) {
     const controlPlaneConfig = opts.config ?? DEFAULT_MU_CONFIG.control_plane;
     const detected = detectAdapters(controlPlaneConfig);
@@ -709,7 +120,7 @@ export async function bootstrapControlPlane(opts) {
     const runtime = new ControlPlaneRuntime({ repoRoot: opts.repoRoot });
     let pipeline = null;
     let runSupervisor = null;
-    let drainInterval = null;
+    let outboxDrainLoop = null;
     const adapterMap = new Map();
     try {
         await runtime.start();
@@ -767,30 +178,9 @@ export async function bootstrapControlPlane(opts) {
                         };
                     }
                     const action = record.target_type;
-                    const hook = action === "reload"
-                        ? opts.sessionMutationHooks?.reload
-                        : opts.sessionMutationHooks?.update;
-                    if (!hook) {
-                        return {
-                            terminalState: "failed",
-                            errorCode: "session_lifecycle_unavailable",
-                            trace: {
-                                cliCommandKind: action,
-                                runRootId: null,
-                            },
-                            mutatingEvents: [
-                                {
-                                    eventType: "session.lifecycle.command.failed",
-                                    payload: {
-                                        action,
-                                        reason: "hook_missing",
-                                    },
-                                },
-                            ],
-                        };
-                    }
+                    const executeLifecycleAction = action === "reload" ? opts.sessionLifecycle.reload : opts.sessionLifecycle.update;
                     try {
-                        const lifecycle = await hook();
+                        const lifecycle = await executeLifecycleAction();
                         if (!lifecycle.ok) {
                             return {
                                 terminalState: "failed",
@@ -1064,38 +454,10 @@ export async function bootstrapControlPlane(opts) {
             }
             return undefined;
         };
-        const dispatcher = new ControlPlaneOutboxDispatcher({ outbox, deliver });
-        let drainingOutbox = false;
-        let drainRequested = false;
-        const drainOutboxNow = async () => {
-            if (drainingOutbox) {
-                drainRequested = true;
-                return;
-            }
-            drainingOutbox = true;
-            try {
-                do {
-                    drainRequested = false;
-                    await dispatcher.drainDue();
-                } while (drainRequested);
-            }
-            catch {
-                // Swallow errors — the dispatcher handles retries internally.
-            }
-            finally {
-                drainingOutbox = false;
-            }
-        };
-        const scheduleOutboxDrain = () => {
-            queueMicrotask(() => {
-                void drainOutboxNow();
-            });
-        };
+        const outboxDrain = createOutboxDrainLoop({ outbox, deliver });
+        const scheduleOutboxDrain = outboxDrain.scheduleOutboxDrain;
         scheduleOutboxDrainRef = scheduleOutboxDrain;
-        drainInterval = setInterval(() => {
-            scheduleOutboxDrain();
-        }, OUTBOX_DRAIN_INTERVAL_MS);
-        scheduleOutboxDrain();
+        outboxDrainLoop = outboxDrain;
         return {
             get activeAdapters() {
                 return [...adapterMap.values()].filter((entry) => entry.isActive()).map((v) => v.info);
@@ -1167,9 +529,9 @@ export async function bootstrapControlPlane(opts) {
                 return await pipeline.handleTerminalInbound(terminalOpts);
             },
             async stop() {
-                if (drainInterval) {
-                    clearInterval(drainInterval);
-                    drainInterval = null;
+                if (outboxDrainLoop) {
+                    outboxDrainLoop.stop();
+                    outboxDrainLoop = null;
                 }
                 for (const { adapter } of adapterMap.values()) {
                     try {
@@ -1190,9 +552,9 @@ export async function bootstrapControlPlane(opts) {
         };
     }
     catch (err) {
-        if (drainInterval) {
-            clearInterval(drainInterval);
-            drainInterval = null;
+        if (outboxDrainLoop) {
+            outboxDrainLoop.stop();
+            outboxDrainLoop = null;
         }
         for (const { adapter } of adapterMap.values()) {
             try {