@femtomc/mu-server 26.2.70 → 26.2.71

package/dist/control_plane.js

@@ -1,8 +1,12 @@
 import { ControlPlaneCommandPipeline, ControlPlaneOutbox, ControlPlaneRuntime, DiscordControlPlaneAdapter, getControlPlanePaths, SlackControlPlaneAdapter, TelegramControlPlaneAdapterSpec, } from "@femtomc/mu-control-plane";
 import { DEFAULT_MU_CONFIG } from "./config.js";
+import { DEFAULT_INTER_ROOT_QUEUE_POLICY, normalizeInterRootQueuePolicy, } from "./control_plane_contract.js";
 import { ControlPlaneRunSupervisor, } from "./run_supervisor.js";
-import { buildMessagingOperatorRuntime, createOutboxDrainLoop, } from "./control_plane_bootstrap_helpers.js";
+import { DurableRunQueue, queueStatesForRunStatusFilter, runSnapshotFromQueueSnapshot } from "./run_queue.js";
+import { buildMessagingOperatorRuntime, createOutboxDrainLoop } from "./control_plane_bootstrap_helpers.js";
+import { ControlPlaneRunQueueCoordinator } from "./control_plane_run_queue_coordinator.js";
 import { enqueueRunEventOutbox } from "./control_plane_run_outbox.js";
+import { buildWakeOutboundEnvelope, resolveWakeFanoutCapability, wakeDeliveryMetadataFromOutboxRecord, wakeDispatchReasonCode, wakeFanoutDedupeKey, } from "./control_plane_wake_delivery.js";
 import { TelegramAdapterGenerationManager } from "./control_plane_telegram_generation.js";
 function generationTags(generation, component) {
     return {
@@ -12,6 +16,25 @@ function generationTags(generation, component) {
         component,
     };
 }
+const WAKE_OUTBOX_MAX_ATTEMPTS = 6;
+function emptyNotifyOperatorsResult() {
+    return {
+        queued: 0,
+        duplicate: 0,
+        skipped: 0,
+        decisions: [],
+    };
+}
+function normalizeIssueId(value) {
+    if (!value) {
+        return null;
+    }
+    const trimmed = value.trim();
+    if (!/^mu-[a-z0-9][a-z0-9-]*$/i.test(trimmed)) {
+        return null;
+    }
+    return trimmed.toLowerCase();
+}
 export function detectAdapters(config) {
     const adapters = [];
     const slackSecret = config.adapters.slack.signing_secret;
@@ -121,6 +144,8 @@ export async function bootstrapControlPlane(opts) {
     let pipeline = null;
     let runSupervisor = null;
     let outboxDrainLoop = null;
+    let wakeDeliveryObserver = opts.wakeDeliveryObserver ?? null;
+    const outboundDeliveryChannels = new Set(["telegram"]);
     const adapterMap = new Map();
     try {
         await runtime.start();
@@ -136,12 +161,20 @@ export async function bootstrapControlPlane(opts) {
         });
         await outbox.load();
         let scheduleOutboxDrainRef = null;
+        const runQueue = new DurableRunQueue({ repoRoot: opts.repoRoot });
+        const interRootQueuePolicy = normalizeInterRootQueuePolicy(opts.interRootQueuePolicy ?? DEFAULT_INTER_ROOT_QUEUE_POLICY);
+        const runQueueCoordinator = new ControlPlaneRunQueueCoordinator({
+            runQueue,
+            interRootQueuePolicy,
+            getRunSupervisor: () => runSupervisor,
+        });
         runSupervisor = new ControlPlaneRunSupervisor({
             repoRoot: opts.repoRoot,
             heartbeatScheduler: opts.heartbeatScheduler,
             heartbeatIntervalMs: opts.runSupervisorHeartbeatIntervalMs,
             spawnProcess: opts.runSupervisorSpawnProcess,
             onEvent: async (event) => {
+                await runQueueCoordinator.onRunEvent(event);
                 const outboxRecord = await enqueueRunEventOutbox({
                     outbox,
                     event,
@@ -152,6 +185,7 @@ export async function bootstrapControlPlane(opts) {
                 }
             },
         });
+        await runQueueCoordinator.scheduleReconcile("bootstrap");
         pipeline = new ControlPlaneCommandPipeline({
             runtime,
             operator,
@@ -247,10 +281,7 @@ export async function bootstrapControlPlane(opts) {
                 }
                 if (record.target_type === "run start" || record.target_type === "run resume") {
                     try {
-                        const launched = await runSupervisor?.startFromCommand(record);
-                        if (!launched) {
-                            return null;
-                        }
+                        const launched = await runQueueCoordinator.launchQueuedRunFromCommand(record);
                         return {
                             terminalState: "completed",
                             result: {
@@ -274,6 +305,8 @@ export async function bootstrapControlPlane(opts) {
                                         run_mode: launched.mode,
                                         run_root_id: launched.root_issue_id,
                                         run_source: launched.source,
+                                        queue_id: launched.queue_id ?? null,
+                                        queue_state: launched.queue_state ?? null,
                                     },
                                 },
                             ],
@@ -282,7 +315,7 @@ export async function bootstrapControlPlane(opts) {
                     catch (err) {
                         return {
                             terminalState: "failed",
-                            errorCode: err instanceof Error && err.message ? err.message : "run_supervisor_start_failed",
+                            errorCode: err instanceof Error && err.message ? err.message : "run_queue_start_failed",
                             trace: {
                                 cliCommandKind: record.target_type.replaceAll(" ", "_"),
                                 runRootId: record.target_id,
@@ -291,9 +324,9 @@ export async function bootstrapControlPlane(opts) {
                     }
                 }
                 if (record.target_type === "run interrupt") {
-                    const result = runSupervisor?.interrupt({
+                    const result = await runQueueCoordinator.interruptQueuedRun({
                         rootIssueId: record.target_id,
-                    }) ?? { ok: false, reason: "not_found", run: null };
+                    });
                     if (!result.ok) {
                         return {
                             terminalState: "failed",
@@ -412,6 +445,104 @@ export async function bootstrapControlPlane(opts) {
             },
             isActive: () => telegramManager.hasActiveGeneration(),
         });
+        const notifyOperators = async (notifyOpts) => {
+            if (!pipeline) {
+                return emptyNotifyOperatorsResult();
+            }
+            const message = notifyOpts.message.trim();
+            const dedupeKey = notifyOpts.dedupeKey.trim();
+            if (!message || !dedupeKey) {
+                return emptyNotifyOperatorsResult();
+            }
+            const wakeSource = typeof notifyOpts.wake?.wakeSource === "string" ? notifyOpts.wake.wakeSource.trim() : "";
+            const wakeProgramId = typeof notifyOpts.wake?.programId === "string" ? notifyOpts.wake.programId.trim() : "";
+            const wakeSourceTsMsRaw = notifyOpts.wake?.sourceTsMs;
+            const wakeSourceTsMs = typeof wakeSourceTsMsRaw === "number" && Number.isFinite(wakeSourceTsMsRaw)
+                ? Math.trunc(wakeSourceTsMsRaw)
+                : null;
+            const wakeId = typeof notifyOpts.wake?.wakeId === "string" && notifyOpts.wake.wakeId.trim().length > 0
+                ? notifyOpts.wake.wakeId.trim()
+                : `wake-${(() => {
+                    const hasher = new Bun.CryptoHasher("sha256");
+                    hasher.update(`${dedupeKey}:${message}`);
+                    return hasher.digest("hex").slice(0, 16);
+                })()}`;
+            const context = {
+                wakeId,
+                dedupeKey,
+                wakeSource: wakeSource || null,
+                programId: wakeProgramId || null,
+                sourceTsMs: wakeSourceTsMs,
+            };
+            const nowMs = Math.trunc(Date.now());
+            const telegramBotToken = telegramManager.activeBotToken();
+            const bindings = pipeline.identities
+                .listBindings({ includeInactive: false })
+                .filter((binding) => binding.scopes.includes("cp.ops.admin"));
+            const result = emptyNotifyOperatorsResult();
+            for (const binding of bindings) {
+                const bindingDedupeKey = wakeFanoutDedupeKey({
+                    dedupeKey,
+                    wakeId,
+                    binding,
+                });
+                const capability = resolveWakeFanoutCapability({
+                    binding,
+                    isChannelDeliverySupported: (channel) => outboundDeliveryChannels.has(channel),
+                    telegramBotToken,
+                });
+                if (!capability.ok) {
+                    result.skipped += 1;
+                    result.decisions.push({
+                        state: "skipped",
+                        reason_code: capability.reasonCode,
+                        binding_id: binding.binding_id,
+                        channel: binding.channel,
+                        dedupe_key: bindingDedupeKey,
+                        outbox_id: null,
+                    });
+                    continue;
+                }
+                const envelope = buildWakeOutboundEnvelope({
+                    repoRoot: opts.repoRoot,
+                    nowMs,
+                    message,
+                    binding,
+                    context,
+                    metadata: notifyOpts.metadata,
+                });
+                const enqueueDecision = await outbox.enqueue({
+                    dedupeKey: bindingDedupeKey,
+                    envelope,
+                    nowMs,
+                    maxAttempts: WAKE_OUTBOX_MAX_ATTEMPTS,
+                });
+                if (enqueueDecision.kind === "enqueued") {
+                    result.queued += 1;
+                    scheduleOutboxDrainRef?.();
+                    result.decisions.push({
+                        state: "queued",
+                        reason_code: "outbox_enqueued",
+                        binding_id: binding.binding_id,
+                        channel: binding.channel,
+                        dedupe_key: bindingDedupeKey,
+                        outbox_id: enqueueDecision.record.outbox_id,
+                    });
+                }
+                else {
+                    result.duplicate += 1;
+                    result.decisions.push({
+                        state: "duplicate",
+                        reason_code: "outbox_duplicate",
+                        binding_id: binding.binding_id,
+                        channel: binding.channel,
+                        dedupe_key: bindingDedupeKey,
+                        outbox_id: enqueueDecision.record.outbox_id,
+                    });
+                }
+            }
+            return result;
+        };
         const deliver = async (record) => {
             const { envelope } = record;
             if (envelope.channel === "telegram") {
@@ -454,7 +585,35 @@ export async function bootstrapControlPlane(opts) {
             }
             return undefined;
         };
-        const outboxDrain = createOutboxDrainLoop({ outbox, deliver });
+        const outboxDrain = createOutboxDrainLoop({
+            outbox,
+            deliver,
+            onOutcome: async (outcome) => {
+                if (!wakeDeliveryObserver) {
+                    return;
+                }
+                const metadata = wakeDeliveryMetadataFromOutboxRecord(outcome.record);
+                if (!metadata) {
+                    return;
+                }
+                const state = outcome.kind === "delivered" ? "delivered" : outcome.kind === "retried" ? "retried" : "dead_letter";
+                await wakeDeliveryObserver({
+                    state,
+                    reason_code: wakeDispatchReasonCode({
+                        state,
+                        lastError: outcome.record.last_error,
+                        deadLetterReason: outcome.record.dead_letter_reason,
+                    }),
+                    wake_id: metadata.wakeId,
+                    dedupe_key: metadata.wakeDedupeKey,
+                    binding_id: metadata.bindingId,
+                    channel: metadata.channel,
+                    outbox_id: metadata.outboxId,
+                    outbox_dedupe_key: metadata.outboxDedupeKey,
+                    attempt_count: outcome.record.attempt_count,
+                });
+            },
+        });
         const scheduleOutboxDrain = outboxDrain.scheduleOutboxDrain;
         scheduleOutboxDrainRef = scheduleOutboxDrain;
         outboxDrainLoop = outboxDrain;
@@ -472,6 +631,12 @@ export async function bootstrapControlPlane(opts) {
                 }
                 return result.response;
             },
+            async notifyOperators(notifyOpts) {
+                return await notifyOperators(notifyOpts);
+            },
+            setWakeDeliveryObserver(observer) {
+                wakeDeliveryObserver = observer;
+            },
             async reloadTelegramGeneration(reloadOpts) {
                 const result = await telegramManager.reload({
                     config: reloadOpts.config,
@@ -483,41 +648,74 @@ export async function bootstrapControlPlane(opts) {
                 return result;
             },
             async listRuns(opts = {}) {
-                return (runSupervisor?.list({
+                const limit = Math.max(1, Math.min(500, Math.trunc(opts.limit ?? 100)));
+                const fallbackStatusFilter = queueStatesForRunStatusFilter(opts.status);
+                if (Array.isArray(fallbackStatusFilter) && fallbackStatusFilter.length === 0) {
+                    return [];
+                }
+                const queued = await runQueue.listRunSnapshots({
                     status: opts.status,
-                    limit: opts.limit,
-                }) ?? []);
+                    limit,
+                    runtimeByJobId: runQueueCoordinator.runtimeSnapshotsByJobId(),
+                });
+                const seen = new Set(queued.map((run) => run.job_id));
+                const fallbackRuns = runSupervisor?.list({ limit: 500 }) ?? [];
+                for (const run of fallbackRuns) {
+                    if (seen.has(run.job_id)) {
+                        continue;
+                    }
+                    if (fallbackStatusFilter && fallbackStatusFilter.length > 0) {
+                        const mapped = run.status === "completed"
+                            ? "done"
+                            : run.status === "failed"
+                                ? "failed"
+                                : run.status === "cancelled"
+                                    ? "cancelled"
+                                    : "active";
+                        if (!fallbackStatusFilter.includes(mapped)) {
+                            continue;
+                        }
+                    }
+                    queued.push(run);
+                    seen.add(run.job_id);
+                }
+                return queued.slice(0, limit);
             },
             async getRun(idOrRoot) {
+                const queued = await runQueue.get(idOrRoot);
+                if (queued) {
+                    const runtime = queued.job_id ? (runSupervisor?.get(queued.job_id) ?? null) : null;
+                    return runSnapshotFromQueueSnapshot(queued, runtime);
+                }
                 return runSupervisor?.get(idOrRoot) ?? null;
             },
             async startRun(startOpts) {
-                const run = await runSupervisor?.launchStart({
+                return await runQueueCoordinator.launchQueuedRun({
+                    mode: "run_start",
                     prompt: startOpts.prompt,
                     maxSteps: startOpts.maxSteps,
                     source: "api",
+                    dedupeKey: `api:run_start:${crypto.randomUUID()}`,
                 });
-                if (!run) {
-                    throw new Error("run_supervisor_unavailable");
-                }
-                return run;
             },
             async resumeRun(resumeOpts) {
-                const run = await runSupervisor?.launchResume({
-                    rootIssueId: resumeOpts.rootIssueId,
+                const rootIssueId = normalizeIssueId(resumeOpts.rootIssueId);
+                if (!rootIssueId) {
+                    throw new Error("run_resume_invalid_root_issue_id");
+                }
+                return await runQueueCoordinator.launchQueuedRun({
+                    mode: "run_resume",
+                    rootIssueId,
                     maxSteps: resumeOpts.maxSteps,
                     source: "api",
+                    dedupeKey: `api:run_resume:${rootIssueId}:${crypto.randomUUID()}`,
                 });
-                if (!run) {
-                    throw new Error("run_supervisor_unavailable");
-                }
-                return run;
             },
             async interruptRun(interruptOpts) {
-                return runSupervisor?.interrupt(interruptOpts) ?? { ok: false, reason: "not_found", run: null };
+                return await runQueueCoordinator.interruptQueuedRun(interruptOpts);
             },
             async heartbeatRun(heartbeatOpts) {
-                return runSupervisor?.heartbeat(heartbeatOpts) ?? { ok: false, reason: "not_found", run: null };
+                return await runQueueCoordinator.heartbeatQueuedRun(heartbeatOpts);
             },
             async traceRun(traceOpts) {
                 return (await runSupervisor?.trace(traceOpts.idOrRoot, { limit: traceOpts.limit })) ?? null;
@@ -529,6 +727,8 @@ export async function bootstrapControlPlane(opts) {
                 return await pipeline.handleTerminalInbound(terminalOpts);
             },
             async stop() {
+                wakeDeliveryObserver = null;
+                runQueueCoordinator.stop();
                 if (outboxDrainLoop) {
                     outboxDrainLoop.stop();
                     outboxDrainLoop = null;
@@ -552,6 +752,7 @@ export async function bootstrapControlPlane(opts) {
         };
     }
     catch (err) {
+        wakeDeliveryObserver = null;
         if (outboxDrainLoop) {
             outboxDrainLoop.stop();
             outboxDrainLoop = null;

package/dist/control_plane_bootstrap_helpers.d.ts

@@ -1,5 +1,5 @@
 import { type MessagingOperatorBackend, MessagingOperatorRuntime } from "@femtomc/mu-agent";
-import { ControlPlaneOutbox, type OutboxDeliveryHandlerResult, type OutboxRecord } from "@femtomc/mu-control-plane";
+import { ControlPlaneOutbox, type OutboxDeliveryHandlerResult, type OutboxDispatchOutcome, type OutboxRecord } from "@femtomc/mu-control-plane";
 import type { ControlPlaneConfig } from "./control_plane_contract.js";
 export declare function buildMessagingOperatorRuntime(opts: {
     repoRoot: string;
@@ -9,6 +9,7 @@ export declare function buildMessagingOperatorRuntime(opts: {
 export declare function createOutboxDrainLoop(opts: {
     outbox: ControlPlaneOutbox;
     deliver: (record: OutboxRecord) => Promise<undefined | OutboxDeliveryHandlerResult>;
+    onOutcome?: (outcome: OutboxDispatchOutcome) => void | Promise<void>;
 }): {
     scheduleOutboxDrain: () => void;
     stop: () => void;

package/dist/control_plane_bootstrap_helpers.js

@@ -40,7 +40,17 @@ export function createOutboxDrainLoop(opts) {
         try {
             do {
                 drainRequested = false;
-                await dispatcher.drainDue();
+                const outcomes = await dispatcher.drainDue();
+                if (opts.onOutcome) {
+                    for (const outcome of outcomes) {
+                        try {
+                            await opts.onOutcome(outcome);
+                        }
+                        catch {
+                            // Keep telemetry callbacks non-fatal.
+                        }
+                    }
+                }
             } while (drainRequested && !stopped);
         }
         catch {

package/dist/control_plane_contract.d.ts

@@ -9,6 +9,14 @@ import type { MuConfig } from "./config.js";
  * - Interface adapters in `control_plane.ts` implement these seams.
  */
 export type ControlPlaneConfig = MuConfig["control_plane"];
+/**
+ * Durable orchestration queue contract (default-on path).
+ *
+ * Scheduler policy/state-machine primitives are owned by `@femtomc/mu-orchestrator` and
+ * re-exported here so existing server/control-plane callers keep a stable import surface.
+ */
+export type { InterRootQueuePolicy, OrchestrationQueueState } from "@femtomc/mu-orchestrator";
+export { DEFAULT_INTER_ROOT_QUEUE_POLICY, normalizeInterRootQueuePolicy, ORCHESTRATION_QUEUE_ALLOWED_TRANSITIONS, ORCHESTRATION_QUEUE_INVARIANTS, } from "@femtomc/mu-orchestrator";
 export type ActiveAdapter = {
     name: Channel;
     route: string;
@@ -76,9 +84,50 @@ export type ControlPlaneSessionLifecycle = {
     reload: () => Promise<ControlPlaneSessionMutationResult>;
     update: () => Promise<ControlPlaneSessionMutationResult>;
 };
+export type WakeDeliveryState = "queued" | "duplicate" | "skipped" | "delivered" | "retried" | "dead_letter";
+export type WakeNotifyDecision = {
+    state: "queued" | "duplicate" | "skipped";
+    reason_code: string;
+    binding_id: string;
+    channel: Channel;
+    dedupe_key: string;
+    outbox_id: string | null;
+};
+export type WakeNotifyContext = {
+    wakeId: string;
+    wakeSource?: string | null;
+    programId?: string | null;
+    sourceTsMs?: number | null;
+};
+export type NotifyOperatorsOpts = {
+    message: string;
+    dedupeKey: string;
+    wake?: WakeNotifyContext | null;
+    metadata?: Record<string, unknown>;
+};
+export type NotifyOperatorsResult = {
+    queued: number;
+    duplicate: number;
+    skipped: number;
+    decisions: WakeNotifyDecision[];
+};
+export type WakeDeliveryEvent = {
+    state: "delivered" | "retried" | "dead_letter";
+    reason_code: string;
+    wake_id: string;
+    dedupe_key: string;
+    binding_id: string;
+    channel: Channel;
+    outbox_id: string;
+    outbox_dedupe_key: string;
+    attempt_count: number;
+};
+export type WakeDeliveryObserver = (event: WakeDeliveryEvent) => void | Promise<void>;
 export type ControlPlaneHandle = {
     activeAdapters: ActiveAdapter[];
     handleWebhook(path: string, req: Request): Promise<Response | null>;
+    notifyOperators?(opts: NotifyOperatorsOpts): Promise<NotifyOperatorsResult>;
+    setWakeDeliveryObserver?(observer: WakeDeliveryObserver | null): void;
     reloadTelegramGeneration?(opts: {
         config: ControlPlaneConfig;
         reason: string;
@@ -88,10 +137,18 @@ export type ControlPlaneHandle = {
         limit?: number;
     }): Promise<ControlPlaneRunSnapshot[]>;
     getRun?(idOrRoot: string): Promise<ControlPlaneRunSnapshot | null>;
+    /**
+     * Run lifecycle boundary: accepts start intent into the default queue/reconcile path.
+     * Compatibility adapters may dispatch immediately after enqueue, but must preserve queue invariants.
+     */
     startRun?(opts: {
         prompt: string;
         maxSteps?: number;
     }): Promise<ControlPlaneRunSnapshot>;
+    /**
+     * Run lifecycle boundary: accepts resume intent into the default queue/reconcile path.
+     * No flag-based alternate path is allowed.
+     */
     resumeRun?(opts: {
         rootIssueId: string;
         maxSteps?: number;

package/dist/control_plane_contract.js

@@ -1 +1 @@
-export {};
+export { DEFAULT_INTER_ROOT_QUEUE_POLICY, normalizeInterRootQueuePolicy, ORCHESTRATION_QUEUE_ALLOWED_TRANSITIONS, ORCHESTRATION_QUEUE_INVARIANTS, } from "@femtomc/mu-orchestrator";

package/dist/control_plane_reload.d.ts

@@ -0,0 +1,63 @@
+import { GenerationTelemetryRecorder, type ReloadableGenerationIdentity, type ReloadLifecycleReason } from "@femtomc/mu-control-plane";
+import type { ControlPlaneConfig, ControlPlaneHandle, TelegramGenerationReloadResult } from "./control_plane_contract.js";
+import { ControlPlaneGenerationSupervisor } from "./generation_supervisor.js";
+export type ControlPlaneSummary = {
+    active: boolean;
+    adapters: string[];
+    routes: Array<{
+        name: string;
+        route: string;
+    }>;
+};
+export type ControlPlaneReloadResult = {
+    ok: boolean;
+    reason: string;
+    previous_control_plane: ControlPlaneSummary;
+    control_plane: ControlPlaneSummary;
+    generation: {
+        attempt_id: string;
+        coalesced: boolean;
+        from_generation: ReloadableGenerationIdentity | null;
+        to_generation: ReloadableGenerationIdentity;
+        active_generation: ReloadableGenerationIdentity | null;
+        outcome: "success" | "failure";
+    };
+    telegram_generation?: TelegramGenerationReloadResult;
+    error?: string;
+};
+export type ControlPlaneReloader = (opts: {
+    repoRoot: string;
+    previous: ControlPlaneHandle | null;
+    config: ControlPlaneConfig;
+    generation: ReloadableGenerationIdentity;
+}) => Promise<ControlPlaneHandle | null>;
+export type ConfigReader = (repoRoot: string) => Promise<import("./config.js").MuConfig>;
+export type ConfigWriter = (repoRoot: string, config: import("./config.js").MuConfig) => Promise<string>;
+export declare function summarizeControlPlane(handle: ControlPlaneHandle | null): ControlPlaneSummary;
+export type ReloadManagerDeps = {
+    repoRoot: string;
+    initialControlPlane: ControlPlaneHandle | null;
+    controlPlaneReloader: ControlPlaneReloader;
+    generationTelemetry: GenerationTelemetryRecorder;
+    loadConfigFromDisk: () => Promise<import("./config.js").MuConfig>;
+};
+export type ReloadManager = {
+    reloadControlPlane: (reason: ReloadLifecycleReason) => Promise<ControlPlaneReloadResult>;
+    getControlPlaneStatus: () => {
+        active: boolean;
+        adapters: string[];
+        routes: Array<{
+            name: string;
+            route: string;
+        }>;
+        generation: import("@femtomc/mu-control-plane").GenerationSupervisorSnapshot;
+        observability: {
+            counters: ReturnType<GenerationTelemetryRecorder["counters"]>;
+        };
+    };
+    getControlPlaneCurrent: () => ControlPlaneHandle | null;
+    setControlPlaneCurrent: (handle: ControlPlaneHandle | null) => void;
+    generationSupervisor: ControlPlaneGenerationSupervisor;
+    generationTelemetry: GenerationTelemetryRecorder;
+};
+export declare function createReloadManager(deps: ReloadManagerDeps): ReloadManager;