@femtomc/mu-server 26.2.70 → 26.2.71

package/dist/server.js

@@ -1,11 +1,11 @@
-import { GenerationTelemetryRecorder, } from "@femtomc/mu-control-plane";
+import { GenerationTelemetryRecorder } from "@femtomc/mu-control-plane";
 import { currentRunId, EventLog, FsJsonlStore, getStorePaths, JsonlEventSink } from "@femtomc/mu-core/node";
 import { ForumStore } from "@femtomc/mu-forum";
 import { IssueStore } from "@femtomc/mu-issue";
 import { ControlPlaneActivitySupervisor } from "./activity_supervisor.js";
 import { DEFAULT_MU_CONFIG, readMuConfigFile, writeMuConfigFile, } from "./config.js";
 import { bootstrapControlPlane } from "./control_plane.js";
-import { ControlPlaneGenerationSupervisor } from "./generation_supervisor.js";
+import { createReloadManager, } from "./control_plane_reload.js";
 import { ActivityHeartbeatScheduler } from "./heartbeat_scheduler.js";
 import { createProcessSessionLifecycle } from "./session_lifecycle.js";
 import { createServerProgramOrchestration } from "./server_program_orchestration.js";
@@ -19,16 +19,85 @@ function describeError(err) {
         return err.message;
     return String(err);
 }
-function summarizeControlPlane(handle) {
-    if (!handle) {
-        return { active: false, adapters: [], routes: [] };
-    }
+function emptyNotifyOperatorsResult() {
     return {
-        active: handle.activeAdapters.length > 0,
-        adapters: handle.activeAdapters.map((adapter) => adapter.name),
-        routes: handle.activeAdapters.map((adapter) => ({ name: adapter.name, route: adapter.route })),
+        queued: 0,
+        duplicate: 0,
+        skipped: 0,
+        decisions: [],
     };
 }
+function normalizeWakeTurnMode(value) {
+    if (typeof value !== "string") {
+        return "off";
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "shadow") {
+        return "shadow";
+    }
+    if (normalized === "active") {
+        return "active";
+    }
+    return "off";
+}
+function stringField(payload, key) {
+    const value = payload[key];
+    if (typeof value !== "string") {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function numberField(payload, key) {
+    const value = payload[key];
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return null;
+    }
+    return Math.trunc(value);
+}
+function computeWakeId(opts) {
+    const source = stringField(opts.payload, "wake_source") ?? "unknown";
+    const programId = stringField(opts.payload, "program_id") ?? "unknown";
+    const sourceTsMs = numberField(opts.payload, "source_ts_ms");
+    const target = Object.hasOwn(opts.payload, "target") ? opts.payload.target : null;
+    let targetFingerprint = "null";
+    try {
+        targetFingerprint = JSON.stringify(target) ?? "null";
+    }
+    catch {
+        targetFingerprint = "[unserializable]";
+    }
+    const hasher = new Bun.CryptoHasher("sha256");
+    hasher.update(`${source}|${programId}|${sourceTsMs ?? "na"}|${opts.dedupeKey}|${targetFingerprint}`);
+    return hasher.digest("hex").slice(0, 16);
+}
+function buildWakeTurnCommandText(opts) {
+    const wakeSource = stringField(opts.payload, "wake_source") ?? "unknown";
+    const programId = stringField(opts.payload, "program_id") ?? "unknown";
+    const wakeMode = stringField(opts.payload, "wake_mode") ?? "immediate";
+    const targetKind = stringField(opts.payload, "target_kind") ?? "unknown";
+    const reason = stringField(opts.payload, "reason") ?? "scheduled";
+    let target = "null";
+    try {
+        target = JSON.stringify(Object.hasOwn(opts.payload, "target") ? opts.payload.target : null) ?? "null";
+    }
+    catch {
+        target = "[unserializable]";
+    }
+    return [
+        "Autonomous wake turn triggered by heartbeat/cron scheduler.",
+        `wake_id=${opts.wakeId}`,
+        `wake_source=${wakeSource}`,
+        `program_id=${programId}`,
+        `wake_mode=${wakeMode}`,
+        `target_kind=${targetKind}`,
+        `reason=${reason}`,
+        `message=${opts.message}`,
+        `target=${target}`,
+        "",
+        "If an action is needed, produce exactly one `/mu ...` command. If no action is needed, provide a short operator response.",
+    ].join("\n");
+}
 export function createContext(repoRoot) {
     const paths = getStorePaths(repoRoot);
     const eventsStore = new FsJsonlStore(paths.eventsPath);
@@ -68,6 +137,12 @@ function createServer(options = {}) {
     const autoRunHeartbeatEveryMs = Math.max(1_000, toNonNegativeInt(options.autoRunHeartbeatEveryMs, DEFAULT_AUTO_RUN_HEARTBEAT_EVERY_MS));
     const operatorWakeLastByKey = new Map();
     const sessionLifecycle = options.sessionLifecycle ?? createProcessSessionLifecycle({ repoRoot });
+    const emitWakeDeliveryEvent = async (payload) => {
+        await context.eventLog.emit("operator.wake.delivery", {
+            source: "mu-server.operator-wake",
+            payload,
+        });
+    };
     const emitOperatorWake = async (opts) => {
         const dedupeKey = opts.dedupeKey.trim();
         if (!dedupeKey) {
@@ -80,6 +155,160 @@ function createServer(options = {}) {
             return false;
         }
         operatorWakeLastByKey.set(dedupeKey, nowMs);
+        const wakeId = computeWakeId({ dedupeKey, payload: opts.payload });
+        const selectedWakeMode = stringField(opts.payload, "wake_mode");
+        const wakeSource = stringField(opts.payload, "wake_source");
+        const programId = stringField(opts.payload, "program_id");
+        const sourceTsMs = numberField(opts.payload, "source_ts_ms");
+        let wakeTurnMode = normalizeWakeTurnMode(fallbackConfig.control_plane.operator.wake_turn_mode);
+        let configReadError = null;
+        try {
+            const config = await loadConfigFromDisk();
+            wakeTurnMode = normalizeWakeTurnMode(config.control_plane.operator.wake_turn_mode);
+        }
+        catch (err) {
+            configReadError = describeError(err);
+        }
+        let decision;
+        if (wakeTurnMode === "off") {
+            decision = {
+                outcome: "skipped",
+                reason: "feature_disabled",
+                wakeTurnMode,
+                selectedWakeMode,
+                turnRequestId: null,
+                turnResultKind: null,
+                error: configReadError,
+            };
+        }
+        else if (wakeTurnMode === "shadow") {
+            decision = {
+                outcome: "skipped",
+                reason: "shadow_mode",
+                wakeTurnMode,
+                selectedWakeMode,
+                turnRequestId: null,
+                turnResultKind: null,
+                error: configReadError,
+            };
+        }
+        else if (typeof controlPlaneProxy.submitTerminalCommand !== "function") {
+            decision = {
+                outcome: "fallback",
+                reason: "control_plane_unavailable",
+                wakeTurnMode,
+                selectedWakeMode,
+                turnRequestId: null,
+                turnResultKind: null,
+                error: configReadError,
+            };
+        }
+        else {
+            const turnRequestId = `wake-turn-${wakeId}`;
+            try {
+                const turnResult = await controlPlaneProxy.submitTerminalCommand({
+                    commandText: buildWakeTurnCommandText({
+                        wakeId,
+                        message: opts.message,
+                        payload: opts.payload,
+                    }),
+                    repoRoot: context.repoRoot,
+                    requestId: turnRequestId,
+                });
+                if (turnResult.kind === "noop" || turnResult.kind === "invalid") {
+                    decision = {
+                        outcome: "fallback",
+                        reason: `turn_result_${turnResult.kind}`,
+                        wakeTurnMode,
+                        selectedWakeMode,
+                        turnRequestId,
+                        turnResultKind: turnResult.kind,
+                        error: configReadError,
+                    };
+                }
+                else {
+                    decision = {
+                        outcome: "triggered",
+                        reason: "turn_invoked",
+                        wakeTurnMode,
+                        selectedWakeMode,
+                        turnRequestId,
+                        turnResultKind: turnResult.kind,
+                        error: configReadError,
+                    };
+                }
+            }
+            catch (err) {
+                const error = describeError(err);
+                decision = {
+                    outcome: "fallback",
+                    reason: error === "control_plane_unavailable" ? "control_plane_unavailable" : "turn_execution_failed",
+                    wakeTurnMode,
+                    selectedWakeMode,
+                    turnRequestId,
+                    turnResultKind: null,
+                    error,
+                };
+            }
+        }
+        await context.eventLog.emit("operator.wake.decision", {
+            source: "mu-server.operator-wake",
+            payload: {
+                wake_id: wakeId,
+                dedupe_key: dedupeKey,
+                wake_source: wakeSource,
+                program_id: programId,
+                source_ts_ms: sourceTsMs,
+                selected_wake_mode: selectedWakeMode,
+                wake_turn_mode: decision.wakeTurnMode,
+                wake_turn_feature_enabled: decision.wakeTurnMode === "active",
+                outcome: decision.outcome,
+                reason: decision.reason,
+                turn_request_id: decision.turnRequestId,
+                turn_result_kind: decision.turnResultKind,
+                error: decision.error,
+            },
+        });
+        let notifyResult = emptyNotifyOperatorsResult();
+        let notifyError = null;
+        if (typeof controlPlaneProxy.notifyOperators === "function") {
+            try {
+                notifyResult = await controlPlaneProxy.notifyOperators({
+                    message: opts.message,
+                    dedupeKey,
+                    wake: {
+                        wakeId,
+                        wakeSource,
+                        programId,
+                        sourceTsMs,
+                    },
+                    metadata: {
+                        wake_delivery_reason: "heartbeat_cron_wake",
+                        wake_turn_outcome: decision.outcome,
+                        wake_turn_reason: decision.reason,
+                    },
+                });
+            }
+            catch (err) {
+                notifyError = describeError(err);
+            }
+        }
+        for (const deliveryDecision of notifyResult.decisions) {
+            await emitWakeDeliveryEvent({
+                state: deliveryDecision.state,
+                reason_code: deliveryDecision.reason_code,
+                wake_id: wakeId,
+                dedupe_key: dedupeKey,
+                binding_id: deliveryDecision.binding_id,
+                channel: deliveryDecision.channel,
+                outbox_id: deliveryDecision.outbox_id,
+                outbox_dedupe_key: deliveryDecision.dedupe_key,
+                attempt_count: null,
+                wake_source: wakeSource,
+                program_id: programId,
+                source_ts_ms: sourceTsMs,
+            });
+        }
         await context.eventLog.emit("operator.wake", {
             source: "mu-server.operator-wake",
             payload: {
@@ -87,28 +316,43 @@ function createServer(options = {}) {
                 dedupe_key: dedupeKey,
                 coalesce_ms: coalesceMs,
                 ...opts.payload,
+                wake_id: wakeId,
+                decision_outcome: decision.outcome,
+                decision_reason: decision.reason,
+                wake_turn_mode: decision.wakeTurnMode,
+                selected_wake_mode: decision.selectedWakeMode,
+                wake_turn_feature_enabled: decision.wakeTurnMode === "active",
+                turn_request_id: decision.turnRequestId,
+                turn_result_kind: decision.turnResultKind,
+                decision_error: decision.error,
+                delivery: {
+                    queued: notifyResult.queued,
+                    duplicate: notifyResult.duplicate,
+                    skipped: notifyResult.skipped,
+                },
+                delivery_summary_v2: {
+                    queued: notifyResult.queued,
+                    duplicate: notifyResult.duplicate,
+                    skipped: notifyResult.skipped,
+                    total: notifyResult.decisions.length,
+                },
+                delivery_error: notifyError,
             },
         });
         return true;
     };
-    let controlPlaneCurrent = options.controlPlane ?? null;
-    let reloadInFlight = null;
     const generationTelemetry = options.generationTelemetry ?? new GenerationTelemetryRecorder();
-    const generationSupervisor = new ControlPlaneGenerationSupervisor({
-        supervisorId: "control-plane",
-        initialGeneration: controlPlaneCurrent
-            ? {
-                generation_id: "control-plane-gen-0",
-                generation_seq: 0,
+    const loadConfigFromDisk = async () => {
+        try {
+            return await readConfig(context.repoRoot);
+        }
+        catch (err) {
+            if (err?.code === "ENOENT") {
+                return fallbackConfig;
             }
-            : null,
-    });
-    const generationTagsFor = (generation, component) => ({
-        generation_id: generation.generation_id,
-        generation_seq: generation.generation_seq,
-        supervisor: "control_plane",
-        component,
-    });
+            throw err;
+        }
+    };
     const controlPlaneReloader = options.controlPlaneReloader ??
         (async ({ repoRoot, config, generation }) => {
             return await bootstrapControlPlane({
@@ -118,75 +362,129 @@ function createServer(options = {}) {
                 generation,
                 telemetry: generationTelemetry,
                 sessionLifecycle,
+                wakeDeliveryObserver: (event) => {
+                    void emitWakeDeliveryEvent({
+                        state: event.state,
+                        reason_code: event.reason_code,
+                        wake_id: event.wake_id,
+                        dedupe_key: event.dedupe_key,
+                        binding_id: event.binding_id,
+                        channel: event.channel,
+                        outbox_id: event.outbox_id,
+                        outbox_dedupe_key: event.outbox_dedupe_key,
+                        attempt_count: event.attempt_count,
+                    });
+                },
                 terminalEnabled: true,
             });
         });
+    const reloadManager = createReloadManager({
+        repoRoot: context.repoRoot,
+        initialControlPlane: options.controlPlane ?? null,
+        controlPlaneReloader,
+        generationTelemetry,
+        loadConfigFromDisk,
+    });
+    const applyWakeDeliveryObserver = () => {
+        const handle = reloadManager.getControlPlaneCurrent();
+        handle?.setWakeDeliveryObserver?.((event) => {
+            void emitWakeDeliveryEvent({
+                state: event.state,
+                reason_code: event.reason_code,
+                wake_id: event.wake_id,
+                dedupe_key: event.dedupe_key,
+                binding_id: event.binding_id,
+                channel: event.channel,
+                outbox_id: event.outbox_id,
+                outbox_dedupe_key: event.outbox_dedupe_key,
+                attempt_count: event.attempt_count,
+            });
+        });
+    };
+    applyWakeDeliveryObserver();
+    const reloadControlPlane = async (reason) => {
+        const result = await reloadManager.reloadControlPlane(reason);
+        applyWakeDeliveryObserver();
+        return result;
+    };
     const controlPlaneProxy = {
         get activeAdapters() {
-            return controlPlaneCurrent?.activeAdapters ?? [];
+            return reloadManager.getControlPlaneCurrent()?.activeAdapters ?? [];
         },
         async handleWebhook(path, req) {
-            const handle = controlPlaneCurrent;
+            const handle = reloadManager.getControlPlaneCurrent();
             if (!handle)
                 return null;
             return await handle.handleWebhook(path, req);
         },
+        async notifyOperators(opts) {
+            const handle = reloadManager.getControlPlaneCurrent();
+            if (!handle?.notifyOperators) {
+                return emptyNotifyOperatorsResult();
+            }
+            return await handle.notifyOperators(opts);
+        },
+        setWakeDeliveryObserver(observer) {
+            const handle = reloadManager.getControlPlaneCurrent();
+            handle?.setWakeDeliveryObserver?.(observer ?? null);
+        },
         async listRuns(opts) {
-            const handle = controlPlaneCurrent;
+            const handle = reloadManager.getControlPlaneCurrent();
             if (!handle?.listRuns)
                 return [];
             return await handle.listRuns(opts);
         },
         async getRun(idOrRoot) {
-            const handle = controlPlaneCurrent;
+            const handle = reloadManager.getControlPlaneCurrent();
             if (!handle?.getRun)
                 return null;
             return await handle.getRun(idOrRoot);
         },
         async startRun(opts) {
-            const handle = controlPlaneCurrent;
+            const handle = reloadManager.getControlPlaneCurrent();
             if (!handle?.startRun) {
                 throw new Error("run_supervisor_unavailable");
             }
             return await handle.startRun(opts);
         },
         async resumeRun(opts) {
-            const handle = controlPlaneCurrent;
+            const handle = reloadManager.getControlPlaneCurrent();
             if (!handle?.resumeRun) {
                 throw new Error("run_supervisor_unavailable");
             }
             return await handle.resumeRun(opts);
         },
         async interruptRun(opts) {
-            const handle = controlPlaneCurrent;
+            const handle = reloadManager.getControlPlaneCurrent();
             if (!handle?.interruptRun) {
                 return { ok: false, reason: "not_found", run: null };
             }
             return await handle.interruptRun(opts);
         },
         async heartbeatRun(opts) {
-            const handle = controlPlaneCurrent;
+            const handle = reloadManager.getControlPlaneCurrent();
             if (!handle?.heartbeatRun) {
                 return { ok: false, reason: "not_found", run: null };
             }
             return await handle.heartbeatRun(opts);
         },
         async traceRun(opts) {
-            const handle = controlPlaneCurrent;
+            const handle = reloadManager.getControlPlaneCurrent();
             if (!handle?.traceRun)
                 return null;
             return await handle.traceRun(opts);
         },
         async submitTerminalCommand(opts) {
-            const handle = controlPlaneCurrent;
+            const handle = reloadManager.getControlPlaneCurrent();
             if (!handle?.submitTerminalCommand) {
                 throw new Error("control_plane_unavailable");
             }
             return await handle.submitTerminalCommand(opts);
         },
         async stop() {
-            const handle = controlPlaneCurrent;
-            controlPlaneCurrent = null;
+            const handle = reloadManager.getControlPlaneCurrent();
+            handle?.setWakeDeliveryObserver?.(null);
+            reloadManager.setControlPlaneCurrent(null);
             await handle?.stop();
         },
     };
@@ -199,490 +497,6 @@ function createServer(options = {}) {
         autoRunHeartbeatEveryMs,
         emitOperatorWake,
     });
-    const loadConfigFromDisk = async () => {
-        try {
-            return await readConfig(context.repoRoot);
-        }
-        catch (err) {
-            if (err?.code === "ENOENT") {
-                return fallbackConfig;
-            }
-            throw err;
-        }
-    };
-    const performControlPlaneReload = async (reason) => {
-        const startedAtMs = Date.now();
-        const planned = generationSupervisor.beginReload(reason);
-        const attempt = planned.attempt;
-        const previous = controlPlaneCurrent;
-        const previousSummary = summarizeControlPlane(previous);
-        const tags = generationTagsFor(attempt.to_generation, "server.reload");
-        const baseFields = {
-            reason,
-            attempt_id: attempt.attempt_id,
-            coalesced: planned.coalesced,
-            from_generation_id: attempt.from_generation?.generation_id ?? null,
-        };
-        const logLifecycle = (opts) => {
-            generationTelemetry.log({
-                level: opts.level,
-                message: `reload transition ${opts.stage}:${opts.state}`,
-                fields: {
-                    ...tags,
-                    ...baseFields,
-                    ...(opts.extra ?? {}),
-                },
-            });
-        };
-        let swapped = false;
-        let failedStage = "warmup";
-        let drainDurationMs = 0;
-        let drainStartedAtMs = null;
-        let nextHandle = null;
-        try {
-            logLifecycle({ level: "info", stage: "warmup", state: "start" });
-            const latestConfig = await loadConfigFromDisk();
-            const telegramGeneration = (await previous?.reloadTelegramGeneration?.({
-                config: latestConfig.control_plane,
-                reason,
-            })) ?? null;
-            if (telegramGeneration?.handled) {
-                if (telegramGeneration.warmup) {
-                    logLifecycle({
-                        level: telegramGeneration.warmup.ok ? "info" : "error",
-                        stage: "warmup",
-                        state: telegramGeneration.warmup.ok ? "complete" : "failed",
-                        extra: {
-                            warmup_elapsed_ms: telegramGeneration.warmup.elapsed_ms,
-                            error: telegramGeneration.warmup.error,
-                            telegram_generation_id: telegramGeneration.to_generation?.generation_id ?? null,
-                        },
-                    });
-                }
-                else {
-                    logLifecycle({
-                        level: "info",
-                        stage: "warmup",
-                        state: "skipped",
-                        extra: {
-                            warmup_reason: "telegram_generation_no_warmup",
-                            telegram_generation_id: telegramGeneration.to_generation?.generation_id ?? null,
-                        },
-                    });
-                }
-                if (telegramGeneration.cutover) {
-                    logLifecycle({ level: "info", stage: "cutover", state: "start" });
-                    logLifecycle({
-                        level: telegramGeneration.cutover.ok ? "info" : "error",
-                        stage: "cutover",
-                        state: telegramGeneration.cutover.ok ? "complete" : "failed",
-                        extra: {
-                            cutover_elapsed_ms: telegramGeneration.cutover.elapsed_ms,
-                            error: telegramGeneration.cutover.error,
-                            active_generation_id: telegramGeneration.active_generation?.generation_id ?? null,
-                        },
-                    });
-                }
-                else {
-                    logLifecycle({
-                        level: "info",
-                        stage: "cutover",
-                        state: "skipped",
-                        extra: {
-                            cutover_reason: "telegram_generation_no_cutover",
-                            active_generation_id: telegramGeneration.active_generation?.generation_id ?? null,
-                        },
-                    });
-                }
-                if (telegramGeneration.drain) {
-                    logLifecycle({ level: "info", stage: "drain", state: "start" });
-                    drainDurationMs = Math.max(0, Math.trunc(telegramGeneration.drain.elapsed_ms));
-                    generationTelemetry.recordDrainDuration(tags, {
-                        durationMs: drainDurationMs,
-                        timedOut: telegramGeneration.drain.timed_out,
-                        metadata: {
-                            ...baseFields,
-                            telegram_forced_stop: telegramGeneration.drain.forced_stop,
-                            telegram_generation_id: telegramGeneration.active_generation?.generation_id ?? null,
-                        },
-                    });
-                    logLifecycle({
-                        level: telegramGeneration.drain.ok ? "info" : "warn",
-                        stage: "drain",
-                        state: telegramGeneration.drain.ok ? "complete" : "failed",
-                        extra: {
-                            drain_duration_ms: telegramGeneration.drain.elapsed_ms,
-                            drain_timed_out: telegramGeneration.drain.timed_out,
-                            forced_stop: telegramGeneration.drain.forced_stop,
-                            error: telegramGeneration.drain.error,
-                        },
-                    });
-                }
-                else {
-                    logLifecycle({
-                        level: "info",
-                        stage: "drain",
-                        state: "skipped",
-                        extra: {
-                            drain_reason: "telegram_generation_no_drain",
-                            telegram_generation_id: telegramGeneration.active_generation?.generation_id ?? null,
-                        },
-                    });
-                }
-                const shouldLogRollbackStart = telegramGeneration.rollback.requested ||
-                    telegramGeneration.rollback.attempted ||
-                    telegramGeneration.rollback.trigger != null ||
-                    !telegramGeneration.ok;
-                if (shouldLogRollbackStart) {
-                    logLifecycle({
-                        level: telegramGeneration.rollback.ok ? "warn" : "error",
-                        stage: "rollback",
-                        state: "start",
-                        extra: {
-                            rollback_requested: telegramGeneration.rollback.requested,
-                            rollback_trigger: telegramGeneration.rollback.trigger,
-                            rollback_attempted: telegramGeneration.rollback.attempted,
-                        },
-                    });
-                    logLifecycle({
-                        level: telegramGeneration.rollback.ok ? "info" : "error",
-                        stage: "rollback",
-                        state: telegramGeneration.rollback.ok ? "complete" : "failed",
-                        extra: {
-                            rollback_requested: telegramGeneration.rollback.requested,
-                            rollback_trigger: telegramGeneration.rollback.trigger,
-                            rollback_attempted: telegramGeneration.rollback.attempted,
-                            error: telegramGeneration.rollback.error,
-                        },
-                    });
-                }
-                else {
-                    logLifecycle({
-                        level: "debug",
-                        stage: "rollback",
-                        state: "skipped",
-                        extra: {
-                            rollback_reason: "not_requested",
-                        },
-                    });
-                }
-                if (telegramGeneration.ok) {
-                    swapped = generationSupervisor.markSwapInstalled(attempt.attempt_id);
-                    generationSupervisor.finishReload(attempt.attempt_id, "success");
-                    const elapsedMs = Math.max(0, Date.now() - startedAtMs);
-                    generationTelemetry.recordReloadSuccess(tags, {
-                        ...baseFields,
-                        elapsed_ms: elapsedMs,
-                        drain_duration_ms: drainDurationMs,
-                        telegram_generation_id: telegramGeneration.active_generation?.generation_id ?? null,
-                        telegram_rollback_attempted: telegramGeneration.rollback.attempted,
-                        telegram_rollback_trigger: telegramGeneration.rollback.trigger,
-                    });
-                    generationTelemetry.trace({
-                        name: "control_plane.reload",
-                        status: "ok",
-                        durationMs: elapsedMs,
-                        fields: {
-                            ...tags,
-                            ...baseFields,
-                            telegram_generation_id: telegramGeneration.active_generation?.generation_id ?? null,
-                        },
-                    });
-                    return {
-                        ok: true,
-                        reason,
-                        previous_control_plane: previousSummary,
-                        control_plane: summarizeControlPlane(controlPlaneCurrent),
-                        generation: {
-                            attempt_id: attempt.attempt_id,
-                            coalesced: planned.coalesced,
-                            from_generation: attempt.from_generation,
-                            to_generation: attempt.to_generation,
-                            active_generation: generationSupervisor.activeGeneration(),
-                            outcome: "success",
-                        },
-                        telegram_generation: telegramGeneration,
-                    };
-                }
-                generationSupervisor.finishReload(attempt.attempt_id, "failure");
-                const error = telegramGeneration.error ?? "telegram_generation_reload_failed";
-                const elapsedMs = Math.max(0, Date.now() - startedAtMs);
-                generationTelemetry.recordReloadFailure(tags, {
-                    ...baseFields,
-                    elapsed_ms: elapsedMs,
-                    drain_duration_ms: drainDurationMs,
-                    error,
-                    telegram_generation_id: telegramGeneration.active_generation?.generation_id ?? null,
-                    telegram_rollback_trigger: telegramGeneration.rollback.trigger,
-                });
-                generationTelemetry.trace({
-                    name: "control_plane.reload",
-                    status: "error",
-                    durationMs: elapsedMs,
-                    fields: {
-                        ...tags,
-                        ...baseFields,
-                        error,
-                        telegram_generation_id: telegramGeneration.active_generation?.generation_id ?? null,
-                        telegram_rollback_trigger: telegramGeneration.rollback.trigger,
-                    },
-                });
-                return {
-                    ok: false,
-                    reason,
-                    previous_control_plane: previousSummary,
-                    control_plane: summarizeControlPlane(controlPlaneCurrent),
-                    generation: {
-                        attempt_id: attempt.attempt_id,
-                        coalesced: planned.coalesced,
-                        from_generation: attempt.from_generation,
-                        to_generation: attempt.to_generation,
-                        active_generation: generationSupervisor.activeGeneration(),
-                        outcome: "failure",
-                    },
-                    telegram_generation: telegramGeneration,
-                    error,
-                };
-            }
-            const next = await controlPlaneReloader({
-                repoRoot: context.repoRoot,
-                previous,
-                config: latestConfig.control_plane,
-                generation: attempt.to_generation,
-            });
-            nextHandle = next;
-            logLifecycle({ level: "info", stage: "warmup", state: "complete" });
-            failedStage = "cutover";
-            logLifecycle({ level: "info", stage: "cutover", state: "start" });
-            controlPlaneCurrent = next;
-            swapped = generationSupervisor.markSwapInstalled(attempt.attempt_id);
-            logLifecycle({
-                level: "info",
-                stage: "cutover",
-                state: "complete",
-                extra: {
-                    active_generation_id: generationSupervisor.activeGeneration()?.generation_id ?? null,
-                },
-            });
-            failedStage = "drain";
-            if (previous && previous !== next) {
-                logLifecycle({ level: "info", stage: "drain", state: "start" });
-                drainStartedAtMs = Date.now();
-                await previous.stop();
-                drainDurationMs = Math.max(0, Date.now() - drainStartedAtMs);
-                generationTelemetry.recordDrainDuration(tags, {
-                    durationMs: drainDurationMs,
-                    metadata: {
-                        ...baseFields,
-                    },
-                });
-                logLifecycle({
-                    level: "info",
-                    stage: "drain",
-                    state: "complete",
-                    extra: {
-                        drain_duration_ms: drainDurationMs,
-                    },
-                });
-            }
-            else {
-                logLifecycle({
-                    level: "info",
-                    stage: "drain",
-                    state: "skipped",
-                    extra: {
-                        drain_reason: "no_previous_generation",
-                    },
-                });
-            }
-            logLifecycle({
-                level: "debug",
-                stage: "rollback",
-                state: "skipped",
-                extra: {
-                    rollback_reason: "not_requested",
-                },
-            });
-            generationSupervisor.finishReload(attempt.attempt_id, "success");
-            const elapsedMs = Math.max(0, Date.now() - startedAtMs);
-            generationTelemetry.recordReloadSuccess(tags, {
-                ...baseFields,
-                elapsed_ms: elapsedMs,
-                drain_duration_ms: drainDurationMs,
-            });
-            generationTelemetry.trace({
-                name: "control_plane.reload",
-                status: "ok",
-                durationMs: elapsedMs,
-                fields: {
-                    ...tags,
-                    ...baseFields,
-                },
-            });
-            return {
-                ok: true,
-                reason,
-                previous_control_plane: previousSummary,
-                control_plane: summarizeControlPlane(next),
-                generation: {
-                    attempt_id: attempt.attempt_id,
-                    coalesced: planned.coalesced,
-                    from_generation: attempt.from_generation,
-                    to_generation: attempt.to_generation,
-                    active_generation: generationSupervisor.activeGeneration(),
-                    outcome: "success",
-                },
-            };
-        }
-        catch (err) {
-            const error = describeError(err);
-            if (failedStage === "drain" && drainStartedAtMs != null) {
-                drainDurationMs = Math.max(0, Date.now() - drainStartedAtMs);
-                generationTelemetry.recordDrainDuration(tags, {
-                    durationMs: drainDurationMs,
-                    metadata: {
-                        ...baseFields,
-                        error,
-                    },
-                });
-            }
-            logLifecycle({
-                level: "error",
-                stage: failedStage,
-                state: "failed",
-                extra: {
-                    error,
-                    drain_duration_ms: failedStage === "drain" ? drainDurationMs : undefined,
-                },
-            });
-            if (swapped) {
-                logLifecycle({
-                    level: "warn",
-                    stage: "rollback",
-                    state: "start",
-                    extra: {
-                        rollback_reason: "reload_failed_after_cutover",
-                        rollback_target_generation_id: attempt.from_generation?.generation_id ?? null,
-                        rollback_source_generation_id: attempt.to_generation.generation_id,
-                    },
-                });
-                if (!previous) {
-                    logLifecycle({
-                        level: "error",
-                        stage: "rollback",
-                        state: "failed",
-                        extra: {
-                            rollback_reason: "no_previous_generation",
-                            rollback_source_generation_id: attempt.to_generation.generation_id,
-                        },
-                    });
-                }
-                else {
-                    try {
-                        const restored = generationSupervisor.rollbackSwapInstalled(attempt.attempt_id);
-                        if (!restored) {
-                            throw new Error("generation_rollback_state_mismatch");
-                        }
-                        controlPlaneCurrent = previous;
-                        if (nextHandle && nextHandle !== previous) {
-                            await nextHandle.stop();
-                        }
-                        logLifecycle({
-                            level: "info",
-                            stage: "rollback",
-                            state: "complete",
-                            extra: {
-                                active_generation_id: generationSupervisor.activeGeneration()?.generation_id ?? null,
-                                rollback_target_generation_id: attempt.from_generation?.generation_id ?? null,
-                            },
-                        });
-                    }
-                    catch (rollbackErr) {
-                        logLifecycle({
-                            level: "error",
-                            stage: "rollback",
-                            state: "failed",
-                            extra: {
-                                error: describeError(rollbackErr),
-                                active_generation_id: generationSupervisor.activeGeneration()?.generation_id ?? null,
-                                rollback_target_generation_id: attempt.from_generation?.generation_id ?? null,
-                                rollback_source_generation_id: attempt.to_generation.generation_id,
-                            },
-                        });
-                    }
-                }
-            }
-            else {
-                logLifecycle({
-                    level: "debug",
-                    stage: "rollback",
-                    state: "skipped",
-                    extra: {
-                        rollback_reason: "cutover_not_installed",
-                    },
-                });
-            }
-            generationSupervisor.finishReload(attempt.attempt_id, "failure");
-            const elapsedMs = Math.max(0, Date.now() - startedAtMs);
-            generationTelemetry.recordReloadFailure(tags, {
-                ...baseFields,
-                elapsed_ms: elapsedMs,
-                drain_duration_ms: drainDurationMs,
-                error,
-            });
-            generationTelemetry.trace({
-                name: "control_plane.reload",
-                status: "error",
-                durationMs: elapsedMs,
-                fields: {
-                    ...tags,
-                    ...baseFields,
-                    error,
-                },
-            });
-            return {
-                ok: false,
-                reason,
-                previous_control_plane: previousSummary,
-                control_plane: summarizeControlPlane(controlPlaneCurrent),
-                generation: {
-                    attempt_id: attempt.attempt_id,
-                    coalesced: planned.coalesced,
-                    from_generation: attempt.from_generation,
-                    to_generation: attempt.to_generation,
-                    active_generation: generationSupervisor.activeGeneration(),
-                    outcome: "failure",
-                },
-                error,
-            };
-        }
-    };
-    const reloadControlPlane = async (reason) => {
-        if (reloadInFlight) {
-            const pending = generationSupervisor.pendingReload();
-            const fallbackGeneration = generationSupervisor.activeGeneration() ??
-                generationSupervisor.snapshot().last_reload?.to_generation ??
-                null;
-            const generation = pending?.to_generation ?? fallbackGeneration;
-            if (generation) {
-                generationTelemetry.recordDuplicateSignal(generationTagsFor(generation, "server.reload"), {
-                    source: "server_reload",
-                    signal: "coalesced_reload_request",
-                    dedupe_key: pending?.attempt_id ?? "reload_in_flight",
-                    record_id: pending?.attempt_id ?? "reload_in_flight",
-                    metadata: {
-                        reason,
-                        pending_reason: pending?.reason ?? null,
-                    },
-                });
-            }
-            return await reloadInFlight;
-        }
-        reloadInFlight = performControlPlaneReload(reason).finally(() => {
-            reloadInFlight = null;
-        });
-        return await reloadInFlight;
-    };
     const handleRequest = createServerRequestHandler({
         context,
         controlPlaneProxy,
@@ -692,16 +506,11 @@ function createServer(options = {}) {
         loadConfigFromDisk,
         writeConfig,
         reloadControlPlane,
-        getControlPlaneStatus: () => ({
-            ...summarizeControlPlane(controlPlaneCurrent),
-            generation: generationSupervisor.snapshot(),
-            observability: {
-                counters: generationTelemetry.counters(),
-            },
-        }),
+        getControlPlaneStatus: reloadManager.getControlPlaneStatus,
         registerAutoRunHeartbeatProgram,
         disableAutoRunHeartbeatProgram,
         describeError,
+        initiateShutdown: options.initiateShutdown,
     });
     const server = {
         port: options.port || 3000,