@gaodefa/daocore 2026.5.86 → 2026.5.88

package/dist/server-reload-handlers-Ccu2KW5E.js

@@ -1,714 +0,0 @@
-import { t as isTruthyEnvValue } from "./env-82mNgG6G.js";
-import { i as formatErrorMessage } from "./errors-D_oyTIw2.js";
-import { n as loadInstalledPluginIndexInstallRecordsSync, t as loadInstalledPluginIndexInstallRecords } from "./installed-plugin-index-record-reader-DFAIDyGb.js";
-import { i as getRuntimeConfig } from "./io-BAMe9xIp.js";
-import "./installed-plugin-index-records-Bl3FZ0wP.js";
-import { n as formatConfigIssueLines } from "./issue-format-c8ezaSew.js";
-import { m as resolveConfigWriteFollowUp } from "./runtime-snapshot-DgdkBEdP.js";
-import "./config-D3DfZ5wH.js";
-import { n as isRestartEnabled } from "./commands.flags-CTkuYPHm.js";
-import { a as deferGatewayRestartUntilIdle, d as resolveGatewayRestartDeferralTimeoutMs, o as emitGatewayRestart, p as setGatewaySigusr1RestartPolicy } from "./restart-CxnHczQO.js";
-import { a as resetModelCatalogCache } from "./model-catalog-CiQmwAly.js";
-import { c as listActiveEmbeddedRunSessionKeys, o as getActiveEmbeddedRunCount, s as listActiveEmbeddedRunSessionIds } from "./run-state-BBTsNRen.js";
-import { l as getTotalQueueSize } from "./command-queue-CUCpLLUI.js";
-import { n as getInspectableActiveTaskRestartBlockers } from "./task-registry.maintenance-d3um7fbo.js";
-import { r as disposeAllSessionMcpRuntimes } from "./pi-bundle-mcp-runtime-CZdP7tUD.js";
-import "./pi-bundle-mcp-tools-CbdQPWo1.js";
-import { a as getActiveSecretsRuntimeSnapshot, n as clearSecretsRuntimeSnapshot } from "./runtime-state-D74mBQBf.js";
-import { r as resetDirectoryCache } from "./target-resolver-bafB-zLT.js";
-import { t as getTotalPendingReplies } from "./dispatcher-registry-CaTZukRA.js";
-import { t as bumpSkillsSnapshotVersion } from "./refresh-state-PCEDjmSb.js";
-import { i as warmCurrentProviderAuthState, t as clearCurrentProviderAuthState } from "./model-provider-auth-BzXwgdDG.js";
-import { _ as resolveHooksConfig } from "./hooks-DapPDFT7.js";
-import { n as markGatewayModelCatalogStaleForReload } from "./server-model-catalog-BRFnHBAJ.js";
-import { a as diffConfigPaths, n as listPluginInstallTimestampMetadataPaths, r as listPluginInstallWholeRecordPaths, t as buildGatewayReloadPlan } from "./config-reload-plan-DetgJ1y8.js";
-import { t as resolveGatewayReloadSettings } from "./config-reload-settings-BCSjTPm-.js";
-import { a as setCurrentSharedGatewaySessionGeneration, n as disconnectStaleSharedGatewayAuthClients } from "./server-shared-auth-generation-Csm1h6QK.js";
-import { t as buildGatewayCronService } from "./server-cron-DFsVLz6k.js";
-import { n as applyGatewayLaneConcurrency, t as resolveHookClientIpConfig } from "./hook-client-ip-config-DoQrN61s.js";
-import { a as startGatewayCronWithLogging, i as startGatewayChannelHealthMonitor } from "./server-runtime-services-BAlijw2O.js";
-import chokidar from "chokidar";
-//#region src/gateway/config-reload.ts
-const MISSING_CONFIG_RETRY_DELAY_MS = 150;
-const MISSING_CONFIG_MAX_RETRIES = 2;
-/**
-* Paths under `skills.*` always change the snapshot that sessions cache in
-* sessions.json. Any prefix match here (for example `skills.allowBundled`,
-* `skills.entries.X.enabled`, `skills.profile`) forces sessions to rebuild
-* their snapshot on the next turn rather than silently advertising stale
-* tools to the model.
-*/
-const SKILLS_INVALIDATION_PREFIXES = ["skills"];
-function matchesSkillsInvalidationPrefix(path) {
-	return SKILLS_INVALIDATION_PREFIXES.some((prefix) => path === prefix || path.startsWith(`${prefix}.`));
-}
-function firstSkillsChangedPath(changedPaths) {
-	return changedPaths.find(matchesSkillsInvalidationPrefix);
-}
-function isNoopReloadPlan(plan) {
-	return !plan.restartGateway && plan.hotReasons.length === 0 && !plan.reloadHooks && !plan.restartGmailWatcher && !plan.restartCron && !plan.restartHeartbeat && !plan.restartHealthMonitor && !plan.reloadPlugins && !plan.disposeMcpRuntimes && plan.restartChannels.size === 0;
-}
-function asPluginInstallConfig(records) {
-	return { plugins: { installs: records } };
-}
-function startGatewayConfigReloader(opts) {
-	let currentConfig = opts.initialConfig;
-	let currentCompareConfig = opts.initialCompareConfig ?? opts.initialConfig;
-	let settings = resolveGatewayReloadSettings(currentConfig);
-	let debounceTimer = null;
-	let pending = false;
-	let running = false;
-	let stopped = false;
-	let restartQueued = false;
-	let missingConfigRetries = 0;
-	let pendingInProcessConfig = null;
-	let lastAppliedWriteHash = opts.initialInternalWriteHash ?? null;
-	let currentPluginInstallRecords = opts.initialPluginInstallRecords ?? loadInstalledPluginIndexInstallRecordsSync();
-	const readPluginInstallRecords = opts.readPluginInstallRecords ?? loadInstalledPluginIndexInstallRecords;
-	const scheduleAfter = (wait) => {
-		if (stopped) return;
-		if (debounceTimer) clearTimeout(debounceTimer);
-		debounceTimer = setTimeout(() => {
-			runReload();
-		}, wait);
-	};
-	const schedule = () => {
-		scheduleAfter(settings.debounceMs);
-	};
-	const queueRestart = (plan, nextConfig) => {
-		if (restartQueued) return;
-		restartQueued = true;
-		(async () => {
-			try {
-				await opts.onRestart(plan, nextConfig);
-			} catch (err) {
-				restartQueued = false;
-				opts.log.error(`config restart failed: ${String(err)}`);
-			}
-		})();
-	};
-	const handleMissingSnapshot = (snapshot) => {
-		if (snapshot.exists) {
-			missingConfigRetries = 0;
-			return false;
-		}
-		if (missingConfigRetries < MISSING_CONFIG_MAX_RETRIES) {
-			missingConfigRetries += 1;
-			opts.log.info(`config reload retry (${missingConfigRetries}/${MISSING_CONFIG_MAX_RETRIES}): config file not found`);
-			scheduleAfter(MISSING_CONFIG_RETRY_DELAY_MS);
-			return true;
-		}
-		opts.log.warn("config reload skipped (config file not found)");
-		return true;
-	};
-	const handleInvalidSnapshot = (snapshot) => {
-		if (snapshot.valid) return false;
-		const issues = formatConfigIssueLines(snapshot.issues, "").join(", ");
-		opts.log.warn(`config reload skipped (invalid config): ${issues}`);
-		return true;
-	};
-	const applySnapshot = async (nextConfig, nextCompareConfig, afterWrite) => {
-		const configChangedPaths = diffConfigPaths(currentCompareConfig, nextCompareConfig);
-		const configPluginInstallTimestampNoopPaths = listPluginInstallTimestampMetadataPaths(currentCompareConfig, nextCompareConfig);
-		const configPluginInstallWholeRecordPaths = listPluginInstallWholeRecordPaths(currentCompareConfig, nextCompareConfig);
-		let nextPluginInstallRecords = currentPluginInstallRecords;
-		try {
-			nextPluginInstallRecords = await readPluginInstallRecords();
-		} catch (err) {
-			opts.log.warn(`config reload plugin install record check failed: ${String(err)}`);
-		}
-		const previousPluginInstallConfig = asPluginInstallConfig(currentPluginInstallRecords);
-		const nextPluginInstallConfig = asPluginInstallConfig(nextPluginInstallRecords);
-		const pluginInstallRecordChangedPaths = diffConfigPaths(previousPluginInstallConfig, nextPluginInstallConfig);
-		const pluginInstallRecordTimestampNoopPaths = listPluginInstallTimestampMetadataPaths(previousPluginInstallConfig, nextPluginInstallConfig);
-		const pluginInstallRecordWholeRecordPaths = listPluginInstallWholeRecordPaths(previousPluginInstallConfig, nextPluginInstallConfig);
-		const changedPaths = [...configChangedPaths, ...pluginInstallRecordChangedPaths];
-		const pluginInstallTimestampNoopPaths = [...configPluginInstallTimestampNoopPaths, ...pluginInstallRecordTimestampNoopPaths];
-		const pluginInstallWholeRecordPaths = [...configPluginInstallWholeRecordPaths, ...pluginInstallRecordWholeRecordPaths];
-		currentConfig = nextConfig;
-		currentCompareConfig = nextCompareConfig;
-		currentPluginInstallRecords = nextPluginInstallRecords;
-		settings = resolveGatewayReloadSettings(nextConfig);
-		if (changedPaths.length === 0) return;
-		const skillsChangedPath = firstSkillsChangedPath(changedPaths);
-		if (skillsChangedPath !== void 0) {
-			bumpSkillsSnapshotVersion({
-				reason: "config-change",
-				changedPath: skillsChangedPath
-			});
-			opts.log.info(`skills snapshot invalidated by config change (${skillsChangedPath})`);
-		}
-		const followUp = resolveConfigWriteFollowUp(afterWrite);
-		opts.log.info(`config change detected; evaluating reload (${changedPaths.join(", ")})`);
-		if (followUp.mode === "none") {
-			opts.log.info(`config reload skipped by writer intent (${followUp.reason})`);
-			return;
-		}
-		const plan = buildGatewayReloadPlan(changedPaths, {
-			noopPaths: pluginInstallTimestampNoopPaths,
-			forceChangedPaths: pluginInstallWholeRecordPaths
-		});
-		if (isNoopReloadPlan(plan) && !followUp.requiresRestart) return;
-		if (settings.mode === "off") {
-			opts.log.info("config reload disabled (gateway.reload.mode=off)");
-			return;
-		}
-		if (followUp.requiresRestart) {
-			queueRestart({
-				...plan,
-				restartGateway: true,
-				restartReasons: [...plan.restartReasons, followUp.reason]
-			}, nextConfig);
-			return;
-		}
-		if (settings.mode === "restart") {
-			queueRestart(plan, nextConfig);
-			return;
-		}
-		if (plan.restartGateway) {
-			if (settings.mode === "hot") {
-				opts.log.warn(`config reload requires gateway restart; hot mode ignoring (${plan.restartReasons.join(", ")})`);
-				return;
-			}
-			queueRestart(plan, nextConfig);
-			return;
-		}
-		await opts.onHotReload(plan, nextConfig);
-	};
-	const promoteAcceptedSnapshot = async (snapshot, reason) => {
-		if (!opts.promoteSnapshot || !snapshot.exists || !snapshot.valid) return;
-		try {
-			await opts.promoteSnapshot(snapshot, reason);
-		} catch (err) {
-			opts.log.warn(`config reload last-known-good promotion failed: ${String(err)}`);
-		}
-	};
-	const promoteAcceptedInProcessWrite = async (persistedHash) => {
-		if (!opts.promoteSnapshot) return;
-		try {
-			const snapshot = await opts.readSnapshot();
-			if (snapshot.hash !== persistedHash || !snapshot.valid) return;
-			await promoteAcceptedSnapshot(snapshot, "in-process-write");
-		} catch (err) {
-			opts.log.warn(`config reload in-process last-known-good promotion failed: ${String(err)}`);
-		}
-	};
-	const runReload = async () => {
-		if (stopped) return;
-		if (running) {
-			pending = true;
-			return;
-		}
-		running = true;
-		if (debounceTimer) {
-			clearTimeout(debounceTimer);
-			debounceTimer = null;
-		}
-		try {
-			if (pendingInProcessConfig) {
-				const pendingWrite = pendingInProcessConfig;
-				pendingInProcessConfig = null;
-				missingConfigRetries = 0;
-				await applySnapshot(pendingWrite.config, pendingWrite.compareConfig, pendingWrite.afterWrite);
-				await promoteAcceptedInProcessWrite(pendingWrite.persistedHash);
-				return;
-			}
-			let snapshot = await opts.readSnapshot();
-			if (lastAppliedWriteHash && typeof snapshot.hash === "string") {
-				if (snapshot.hash === lastAppliedWriteHash) return;
-				lastAppliedWriteHash = null;
-			}
-			if (handleMissingSnapshot(snapshot)) return;
-			if (!snapshot.valid) {
-				handleInvalidSnapshot(snapshot);
-				return;
-			}
-			await applySnapshot(snapshot.config, snapshot.sourceConfig);
-			await promoteAcceptedSnapshot(snapshot, "valid-config");
-		} catch (err) {
-			opts.log.error(`config reload failed: ${String(err)}`);
-		} finally {
-			running = false;
-			if (pending) {
-				pending = false;
-				schedule();
-			}
-		}
-	};
-	const watcher = chokidar.watch(opts.watchPath, {
-		ignoreInitial: true,
-		awaitWriteFinish: {
-			stabilityThreshold: 200,
-			pollInterval: 50
-		},
-		usePolling: Boolean(process.env.VITEST)
-	});
-	const scheduleFromWatcher = () => {
-		schedule();
-	};
-	const unsubscribeFromWrites = opts.subscribeToWrites?.((event) => {
-		if (event.configPath !== opts.watchPath) return;
-		pendingInProcessConfig = {
-			config: event.runtimeConfig,
-			compareConfig: event.sourceConfig,
-			persistedHash: event.persistedHash,
-			afterWrite: event.afterWrite
-		};
-		lastAppliedWriteHash = event.persistedHash;
-		scheduleAfter(0);
-	}) ?? (() => {});
-	watcher.on("add", scheduleFromWatcher);
-	watcher.on("change", scheduleFromWatcher);
-	watcher.on("unlink", scheduleFromWatcher);
-	let watcherClosed = false;
-	watcher.on("error", (err) => {
-		if (watcherClosed) return;
-		watcherClosed = true;
-		opts.log.warn(`config watcher error: ${String(err)}`);
-		watcher.close().catch(() => {});
-	});
-	return { stop: async () => {
-		stopped = true;
-		if (debounceTimer) clearTimeout(debounceTimer);
-		debounceTimer = null;
-		watcherClosed = true;
-		unsubscribeFromWrites();
-		await watcher.close().catch(() => {});
-	} };
-}
-//#endregion
-//#region src/gateway/server-reload-handlers.ts
-async function activateSecretsRuntimeSnapshot(snapshot) {
-	(await import("./runtime-gvbnjyQA.js")).activateSecretsRuntimeSnapshot(snapshot);
-}
-const MCP_RUNTIME_RELOAD_DISPOSE_TIMEOUT_MS = 5e3;
-const CHANNEL_RELOAD_DEFERRAL_POLL_MS = 500;
-const CHANNEL_RELOAD_STILL_PENDING_WARN_MS = 3e4;
-function resetPreparedModelRuntimeStateForHotReload() {
-	resetModelCatalogCache();
-	clearCurrentProviderAuthState();
-	markGatewayModelCatalogStaleForReload();
-}
-async function disposeMcpRuntimesWithTimeout(params) {
-	let timer;
-	const disposePromise = params.dispose().catch((error) => {
-		params.onWarn(`${params.label} failed: ${String(error)}`);
-	});
-	const timeoutPromise = new Promise((resolve) => {
-		timer = setTimeout(() => resolve("timeout"), params.timeoutMs);
-		timer.unref?.();
-	});
-	const result = await Promise.race([disposePromise.then(() => "done"), timeoutPromise]);
-	if (timer) clearTimeout(timer);
-	if (result === "timeout") params.onWarn(`${params.label} exceeded ${params.timeoutMs}ms; continuing`);
-}
-async function collectChannelOperationFailures(params) {
-	const failures = [];
-	for (const channel of params.channels) try {
-		await params.run(channel);
-	} catch (err) {
-		failures.push(channel);
-		params.onFailure(channel, err);
-	}
-	return failures;
-}
-function createGatewayReloadHandlers(params) {
-	const getActiveCounts = () => {
-		const queueSize = getTotalQueueSize();
-		const pendingReplies = getTotalPendingReplies();
-		const embeddedRuns = getActiveEmbeddedRunCount();
-		const activeTasks = getInspectableActiveTaskRestartBlockers().length;
-		return {
-			queueSize,
-			pendingReplies,
-			embeddedRuns,
-			activeTasks,
-			totalActive: queueSize + pendingReplies + embeddedRuns + activeTasks
-		};
-	};
-	const formatActiveDetails = (counts) => {
-		const details = [];
-		if (counts.queueSize > 0) details.push(`${counts.queueSize} operation(s)`);
-		if (counts.pendingReplies > 0) details.push(`${counts.pendingReplies} reply(ies)`);
-		if (counts.embeddedRuns > 0) details.push(`${counts.embeddedRuns} embedded run(s)`);
-		if (counts.activeTasks > 0) details.push(`${counts.activeTasks} background task run(s)`);
-		return details;
-	};
-	const formatTaskBlocker = (task) => {
-		return [
-			`taskId=${task.taskId}`,
-			task.runId ? `runId=${task.runId}` : null,
-			`status=${task.status}`,
-			`runtime=${task.runtime}`,
-			task.label ? `label=${task.label}` : null,
-			task.title ? `title=${task.title.slice(0, 80)}` : null
-		].filter((value) => Boolean(value)).join(" ");
-	};
-	const formatTaskBlockers = () => {
-		const blockers = getInspectableActiveTaskRestartBlockers();
-		if (blockers.length === 0) return null;
-		const shown = blockers.slice(0, 8).map(formatTaskBlocker);
-		const omitted = blockers.length - shown.length;
-		return omitted > 0 ? `${shown.join("; ")}; +${omitted} more` : shown.join("; ");
-	};
-	const collectActiveRestartSessionKeys = () => {
-		return new Set(listActiveEmbeddedRunSessionKeys());
-	};
-	const collectActiveRestartSessionIds = () => {
-		return new Set(listActiveEmbeddedRunSessionIds());
-	};
-	const markActiveMainSessionsForRestart = async (nextConfig, reason) => {
-		const sessionKeys = collectActiveRestartSessionKeys();
-		const sessionIds = collectActiveRestartSessionIds();
-		if (sessionKeys.size === 0 && sessionIds.size === 0) return;
-		const { markRestartAbortedMainSessions } = await import("./main-session-restart-recovery-DwPQbTAd.js");
-		await markRestartAbortedMainSessions({
-			cfg: nextConfig,
-			additionalCfgs: [getRuntimeConfig()],
-			sessionKeys,
-			sessionIds,
-			reason
-		});
-	};
-	const waitForActiveWorkBeforeChannelReload = async (channels, nextConfig) => {
-		const initial = getActiveCounts();
-		if (initial.totalActive <= 0) return;
-		const channelNames = [...channels].join(", ");
-		const initialDetails = formatActiveDetails(initial);
-		params.logReload.warn(`config change requires channel reload (${channelNames}) — deferring until ${initialDetails.join(", ")} complete`);
-		const timeoutMs = resolveGatewayRestartDeferralTimeoutMs(nextConfig.gateway?.reload?.deferralTimeoutMs);
-		const startedAt = Date.now();
-		let nextStillPendingAt = startedAt + CHANNEL_RELOAD_STILL_PENDING_WARN_MS;
-		while (true) {
-			await new Promise((resolve) => {
-				setTimeout(resolve, CHANNEL_RELOAD_DEFERRAL_POLL_MS).unref?.();
-			});
-			const current = getActiveCounts();
-			if (current.totalActive <= 0) {
-				params.logReload.info("active operations and replies completed; reloading channels now");
-				return;
-			}
-			const elapsedMs = Date.now() - startedAt;
-			if (timeoutMs !== void 0 && elapsedMs >= timeoutMs) {
-				const remaining = formatActiveDetails(current);
-				params.logReload.warn(`channel reload timeout after ${elapsedMs}ms with ${remaining.join(", ")} still active; reloading channels anyway`);
-				return;
-			}
-			if (Date.now() >= nextStillPendingAt) {
-				const remaining = formatActiveDetails(current);
-				params.logReload.warn(`channel reload still deferred after ${elapsedMs}ms with ${remaining.join(", ")} active`);
-				nextStillPendingAt = Date.now() + CHANNEL_RELOAD_STILL_PENDING_WARN_MS;
-			}
-		}
-	};
-	const applyHotReload = async (plan, nextConfig) => {
-		setGatewaySigusr1RestartPolicy({ allowExternal: isRestartEnabled(nextConfig) });
-		const state = params.getState();
-		const nextState = { ...state };
-		resetPreparedModelRuntimeStateForHotReload();
-		if (plan.reloadHooks) try {
-			nextState.hooksConfig = resolveHooksConfig(nextConfig);
-		} catch (err) {
-			params.logHooks.warn(`hooks config reload failed: ${String(err)}`);
-		}
-		nextState.hookClientIpConfig = resolveHookClientIpConfig(nextConfig);
-		if (plan.restartHeartbeat) nextState.heartbeatRunner.updateConfig(nextConfig);
-		resetDirectoryCache();
-		const channelsToRestart = new Set(plan.restartChannels);
-		const channelsStoppedBeforePluginReload = /* @__PURE__ */ new Set();
-		let activePluginChannelsAfterReload = null;
-		const shouldSkipChannelRestart = () => isTruthyEnvValue(process.env.DAOCORE_SKIP_CHANNELS) || isTruthyEnvValue(process.env.DAOCORE_SKIP_PROVIDERS);
-		if (plan.reloadPlugins) {
-			const stopChannelsBeforePluginReplace = async (channels) => {
-				for (const channel of channels) channelsToRestart.add(channel);
-				if (channelsToRestart.size === 0 || shouldSkipChannelRestart()) return;
-				await waitForActiveWorkBeforeChannelReload(channelsToRestart, nextConfig);
-				const stoppedChannels = [];
-				const stopFailures = await collectChannelOperationFailures({
-					channels: channelsToRestart,
-					run: async (channel) => {
-						if (channelsStoppedBeforePluginReload.has(channel)) return;
-						params.logChannels.info(`stopping ${channel} channel before plugin reload`);
-						stoppedChannels.push(channel);
-						await params.stopChannel(channel, void 0, { manual: false });
-						channelsStoppedBeforePluginReload.add(channel);
-					},
-					onFailure: (channel, err) => {
-						params.logChannels.error(`failed to stop ${channel} channel before plugin reload: ${formatErrorMessage(err)}`);
-					}
-				});
-				if (stopFailures.length > 0) {
-					const rollbackFailures = await collectChannelOperationFailures({
-						channels: stoppedChannels,
-						run: async (channel) => {
-							params.logChannels.info(`restarting ${channel} channel after failed plugin reload pre-stop`);
-							await params.startChannel(channel);
-							channelsStoppedBeforePluginReload.delete(channel);
-						},
-						onFailure: (channel, err) => {
-							params.logChannels.error(`failed to restart ${channel} channel after failed plugin reload pre-stop: ${formatErrorMessage(err)}`);
-						}
-					});
-					const rollbackSuffix = rollbackFailures.length > 0 ? `; rollback restart failed for: ${rollbackFailures.join(", ")}` : "";
-					throw new Error(`failed to stop channels before plugin reload: ${stopFailures.join(", ")}${rollbackSuffix}`);
-				}
-			};
-			const pluginReloadResult = await params.reloadPlugins({
-				nextConfig,
-				changedPaths: plan.changedPaths,
-				beforeReplace: stopChannelsBeforePluginReplace
-			});
-			for (const channel of pluginReloadResult.restartChannels) channelsToRestart.add(channel);
-			activePluginChannelsAfterReload = pluginReloadResult.activeChannels;
-			resetPreparedModelRuntimeStateForHotReload();
-		}
-		if (plan.restartCron) {
-			params.onCronRestart?.();
-			state.cronState.cron.stop();
-			nextState.cronState = buildGatewayCronService({
-				cfg: nextConfig,
-				deps: params.deps,
-				broadcast: params.broadcast
-			});
-			startGatewayCronWithLogging({
-				cron: nextState.cronState.cron,
-				logCron: params.logCron
-			});
-		}
-		if (plan.restartHealthMonitor) {
-			state.channelHealthMonitor?.stop();
-			nextState.channelHealthMonitor = params.createHealthMonitor(nextConfig);
-		}
-		if (plan.disposeMcpRuntimes) await disposeMcpRuntimesWithTimeout({
-			dispose: disposeAllSessionMcpRuntimes,
-			timeoutMs: MCP_RUNTIME_RELOAD_DISPOSE_TIMEOUT_MS,
-			onWarn: params.logReload.warn,
-			label: "bundle-mcp runtime disposal during config reload"
-		});
-		if (plan.restartGmailWatcher) {
-			params.stopPostReadySidecars?.();
-			const restartAbortController = params.createGmailRestartAbortController?.() ?? new AbortController();
-			try {
-				if (!restartAbortController.signal.aborted) {
-					const [{ stopGmailWatcher }, { startGmailWatcherWithLogs }] = await Promise.all([import("./gmail-watcher-D_b9Zohm.js"), import("./gmail-watcher-lifecycle-00GBIydO.js")]);
-					if (!restartAbortController.signal.aborted) await stopGmailWatcher().catch((err) => {
-						params.logHooks.warn(`gmail watcher stop failed during reload: ${String(err)}`);
-					});
-					if (!restartAbortController.signal.aborted) await startGmailWatcherWithLogs({
-						cfg: nextConfig,
-						log: params.logHooks,
-						isCancelled: () => restartAbortController.signal.aborted,
-						signal: restartAbortController.signal,
-						onSkipped: () => params.logHooks.info("skipping gmail watcher restart (DAOCORE_SKIP_GMAIL_WATCHER=1)")
-					});
-				}
-			} finally {
-				params.clearGmailRestartAbortController?.(restartAbortController);
-			}
-		}
-		if (channelsToRestart.size > 0) if (shouldSkipChannelRestart()) params.logChannels.info("skipping channel reload (DAOCORE_SKIP_CHANNELS=1 or DAOCORE_SKIP_PROVIDERS=1)");
-		else {
-			if (!plan.reloadPlugins) await waitForActiveWorkBeforeChannelReload(channelsToRestart, nextConfig);
-			const restartChannel = async (name) => {
-				if (plan.reloadPlugins && activePluginChannelsAfterReload?.has(name) === false) return;
-				params.logChannels.info(`restarting ${name} channel`);
-				if (!channelsStoppedBeforePluginReload.has(name)) await params.stopChannel(name, void 0, { manual: false });
-				await params.startChannel(name);
-			};
-			const restartFailures = await collectChannelOperationFailures({
-				channels: channelsToRestart,
-				run: restartChannel,
-				onFailure: (channel, err) => {
-					params.logChannels.error(`failed to restart ${channel} channel during hot reload: ${formatErrorMessage(err)}`);
-				}
-			});
-			if (restartFailures.length > 0) throw new Error(`failed to restart channels during hot reload: ${restartFailures.join(", ")}`);
-		}
-		applyGatewayLaneConcurrency(nextConfig);
-		warmCurrentProviderAuthState(nextConfig).catch((err) => {
-			params.logReload.warn(`provider auth state rewarm failed: ${String(err)}`);
-		});
-		if (plan.hotReasons.length > 0) params.logReload.info(`config hot reload applied (${plan.hotReasons.join(", ")})`);
-		else if (plan.noopPaths.length > 0) params.logReload.info(`config change applied (dynamic reads: ${plan.noopPaths.join(", ")})`);
-		params.setState(nextState);
-	};
-	let restartPending = false;
-	const requestGatewayRestart = (plan, nextConfig) => {
-		setGatewaySigusr1RestartPolicy({ allowExternal: isRestartEnabled(nextConfig) });
-		const reasons = plan.restartReasons.length ? plan.restartReasons.join(", ") : plan.changedPaths.join(", ");
-		if (process.listenerCount("SIGUSR1") === 0) {
-			params.logReload.warn("no SIGUSR1 listener found; restart skipped");
-			return false;
-		}
-		const active = getActiveCounts();
-		if (active.totalActive > 0) {
-			if (restartPending) {
-				params.logReload.info(`config change requires gateway restart (${reasons}) — already waiting for operations to complete`);
-				return true;
-			}
-			restartPending = true;
-			const initialDetails = formatActiveDetails(active);
-			params.logReload.warn(`config change requires gateway restart (${reasons}) — deferring until ${initialDetails.join(", ")} complete`);
-			const taskBlockers = formatTaskBlockers();
-			if (taskBlockers) params.logReload.warn(`restart blocked by active background task run(s): ${taskBlockers}`);
-			deferGatewayRestartUntilIdle({
-				getPendingCount: () => getActiveCounts().totalActive,
-				maxWaitMs: resolveGatewayRestartDeferralTimeoutMs(nextConfig.gateway?.reload?.deferralTimeoutMs),
-				emitHooks: { beforeEmit: () => markActiveMainSessionsForRestart(nextConfig, "config reload forced restart") },
-				hooks: {
-					onReady: () => {
-						restartPending = false;
-						params.logReload.info("all operations and replies completed; restarting gateway now");
-					},
-					onStillPending: (_pending, elapsedMs) => {
-						const remaining = formatActiveDetails(getActiveCounts());
-						const taskBlockers = formatTaskBlockers();
-						params.logReload.warn(`restart still deferred after ${elapsedMs}ms with ${remaining.join(", ")} active${taskBlockers ? ` (${taskBlockers})` : ""}`);
-					},
-					onTimeout: (_pending, elapsedMs) => {
-						const remaining = formatActiveDetails(getActiveCounts());
-						const taskBlockers = formatTaskBlockers();
-						restartPending = false;
-						params.logReload.warn(`restart timeout after ${elapsedMs}ms with ${remaining.join(", ")} still active${taskBlockers ? ` (${taskBlockers})` : ""}; forcing restart`);
-					},
-					onCheckError: (err) => {
-						restartPending = false;
-						params.logReload.warn(`restart deferral check failed (${String(err)}); restarting gateway now`);
-					}
-				}
-			});
-			return true;
-		}
-		params.logReload.warn(`config change requires gateway restart (${reasons})`);
-		if (!emitGatewayRestart()) params.logReload.info("gateway restart already scheduled; skipping duplicate signal");
-		return true;
-	};
-	return {
-		applyHotReload,
-		requestGatewayRestart
-	};
-}
-function startManagedGatewayConfigReloader(params) {
-	if (params.minimalTestGateway) return { stop: async () => {} };
-	let stopped = false;
-	let activeGmailRestartAbortController = null;
-	const abortActiveGmailRestart = () => {
-		activeGmailRestartAbortController?.abort();
-		activeGmailRestartAbortController = null;
-	};
-	const createGmailRestartAbortController = () => {
-		abortActiveGmailRestart();
-		const abortController = new AbortController();
-		if (stopped) {
-			abortController.abort();
-			return abortController;
-		}
-		activeGmailRestartAbortController = abortController;
-		return abortController;
-	};
-	const { applyHotReload, requestGatewayRestart } = createGatewayReloadHandlers({
-		deps: params.deps,
-		broadcast: params.broadcast,
-		getState: params.getState,
-		setState: params.setState,
-		startChannel: params.startChannel,
-		stopChannel: params.stopChannel,
-		stopPostReadySidecars: params.stopPostReadySidecars,
-		reloadPlugins: params.reloadPlugins,
-		logHooks: params.logHooks,
-		logChannels: params.logChannels,
-		logCron: params.logCron,
-		logReload: params.logReload,
-		createGmailRestartAbortController,
-		clearGmailRestartAbortController: (abortController) => {
-			if (activeGmailRestartAbortController === abortController) activeGmailRestartAbortController = null;
-		},
-		...params.onCronRestart ? { onCronRestart: params.onCronRestart } : {},
-		createHealthMonitor: (config) => startGatewayChannelHealthMonitor({
-			cfg: config,
-			channelManager: params.channelManager
-		})
-	});
-	const configReloader = startGatewayConfigReloader({
-		initialConfig: params.initialConfig,
-		initialCompareConfig: params.initialCompareConfig,
-		initialInternalWriteHash: params.initialInternalWriteHash,
-		readSnapshot: params.readSnapshot,
-		promoteSnapshot: async (snapshot, _reason) => await params.promoteSnapshot(snapshot),
-		subscribeToWrites: params.subscribeToWrites,
-		onHotReload: async (plan, nextConfig) => {
-			const previousSharedGatewaySessionGeneration = params.sharedGatewaySessionGenerationState.current;
-			const previousSnapshot = getActiveSecretsRuntimeSnapshot();
-			const prepared = await params.activateRuntimeSecrets(nextConfig, {
-				reason: "reload",
-				activate: true
-			});
-			const nextSharedGatewaySessionGeneration = params.resolveSharedGatewaySessionGenerationForConfig(prepared.config);
-			params.sharedGatewaySessionGenerationState.current = nextSharedGatewaySessionGeneration;
-			const sharedGatewaySessionGenerationChanged = previousSharedGatewaySessionGeneration !== nextSharedGatewaySessionGeneration;
-			if (sharedGatewaySessionGenerationChanged) disconnectStaleSharedGatewayAuthClients({
-				clients: params.clients,
-				expectedGeneration: nextSharedGatewaySessionGeneration
-			});
-			try {
-				await applyHotReload(plan, prepared.config);
-			} catch (err) {
-				if (previousSnapshot) await activateSecretsRuntimeSnapshot(previousSnapshot);
-				else clearSecretsRuntimeSnapshot();
-				params.sharedGatewaySessionGenerationState.current = previousSharedGatewaySessionGeneration;
-				if (sharedGatewaySessionGenerationChanged) disconnectStaleSharedGatewayAuthClients({
-					clients: params.clients,
-					expectedGeneration: previousSharedGatewaySessionGeneration
-				});
-				throw err;
-			}
-			setCurrentSharedGatewaySessionGeneration(params.sharedGatewaySessionGenerationState, nextSharedGatewaySessionGeneration);
-		},
-		onRestart: async (plan, nextConfig) => {
-			const previousRequiredSharedGatewaySessionGeneration = params.sharedGatewaySessionGenerationState.required;
-			const previousSharedGatewaySessionGeneration = params.sharedGatewaySessionGenerationState.current;
-			try {
-				const prepared = await params.activateRuntimeSecrets(nextConfig, {
-					reason: "restart-check",
-					activate: false
-				});
-				const nextSharedGatewaySessionGeneration = params.resolveSharedGatewaySessionGenerationForConfig(prepared.config);
-				if (!requestGatewayRestart(plan, nextConfig)) {
-					if (previousSharedGatewaySessionGeneration !== nextSharedGatewaySessionGeneration) {
-						await activateSecretsRuntimeSnapshot(prepared);
-						setCurrentSharedGatewaySessionGeneration(params.sharedGatewaySessionGenerationState, nextSharedGatewaySessionGeneration);
-						params.sharedGatewaySessionGenerationState.required = null;
-						disconnectStaleSharedGatewayAuthClients({
-							clients: params.clients,
-							expectedGeneration: nextSharedGatewaySessionGeneration
-						});
-					} else params.sharedGatewaySessionGenerationState.required = null;
-					return;
-				}
-				if (previousSharedGatewaySessionGeneration !== nextSharedGatewaySessionGeneration) {
-					params.sharedGatewaySessionGenerationState.required = nextSharedGatewaySessionGeneration;
-					disconnectStaleSharedGatewayAuthClients({
-						clients: params.clients,
-						expectedGeneration: nextSharedGatewaySessionGeneration
-					});
-				} else params.sharedGatewaySessionGenerationState.required = null;
-			} catch (error) {
-				params.sharedGatewaySessionGenerationState.required = previousRequiredSharedGatewaySessionGeneration;
-				throw error;
-			}
-		},
-		log: {
-			info: (msg) => params.logReload.info(msg),
-			warn: (msg) => params.logReload.warn(msg),
-			error: (msg) => params.logReload.error(msg)
-		},
-		watchPath: params.watchPath
-	});
-	return { stop: async () => {
-		stopped = true;
-		abortActiveGmailRestart();
-		await configReloader.stop();
-	} };
-}
-//#endregion
-export { startManagedGatewayConfigReloader };