@pixelzx/genesis 2026.6.27 → 2026.6.29

package/dist/image-fallbacks-Cy-kcJR5.js

@@ -0,0 +1,2 @@
+import { i as modelsImageFallbacksRemoveCommand, n as modelsImageFallbacksClearCommand, r as modelsImageFallbacksListCommand, t as modelsImageFallbacksAddCommand } from "./image-fallbacks-DoQoUiR7.js";
+export { modelsImageFallbacksAddCommand, modelsImageFallbacksClearCommand, modelsImageFallbacksListCommand, modelsImageFallbacksRemoveCommand };

package/dist/image-fallbacks-DoQoUiR7.js

@@ -0,0 +1,31 @@
+import { i as removeFallbackCommand, n as clearFallbacksCommand, r as listFallbacksCommand, t as addFallbackCommand } from "./fallbacks-shared-4iQjz5v5.js";
+//#region src/commands/models/image-fallbacks.ts
+async function modelsImageFallbacksListCommand(opts, runtime) {
+	return await listFallbacksCommand({
+		label: "Image fallbacks",
+		key: "imageModel"
+	}, opts, runtime);
+}
+async function modelsImageFallbacksAddCommand(modelRaw, runtime) {
+	return await addFallbackCommand({
+		label: "Image fallbacks",
+		key: "imageModel",
+		logPrefix: "Image fallbacks"
+	}, modelRaw, runtime);
+}
+async function modelsImageFallbacksRemoveCommand(modelRaw, runtime) {
+	return await removeFallbackCommand({
+		label: "Image fallbacks",
+		key: "imageModel",
+		notFoundLabel: "Image fallback",
+		logPrefix: "Image fallbacks"
+	}, modelRaw, runtime);
+}
+async function modelsImageFallbacksClearCommand(runtime) {
+	return await clearFallbacksCommand({
+		key: "imageModel",
+		clearedMessage: "Image fallback list cleared."
+	}, runtime);
+}
+//#endregion
+export { modelsImageFallbacksRemoveCommand as i, modelsImageFallbacksClearCommand as n, modelsImageFallbacksListCommand as r, modelsImageFallbacksAddCommand as t };

package/dist/inbound-reply-dispatch-jQhsUF0f.js

@@ -0,0 +1,73 @@
+import { n as createNormalizedOutboundDeliverer } from "./reply-payload-CWBVBJ1c.js";
+import { c as withReplyDispatcher, s as dispatchReplyFromConfig } from "./dispatch-Dew5dCZ_.js";
+import { t as createChannelReplyPipeline } from "./channel-reply-pipeline-BbFpiuUk.js";
+//#region src/plugin-sdk/inbound-reply-dispatch.ts
+/** Run `dispatchReplyFromConfig` with a dispatcher that always gets its settled callback. */
+async function dispatchReplyFromConfigWithSettledDispatcher(params) {
+	return await withReplyDispatcher({
+		dispatcher: params.dispatcher,
+		onSettled: params.onSettled,
+		run: () => dispatchReplyFromConfig({
+			ctx: params.ctxPayload,
+			cfg: params.cfg,
+			dispatcher: params.dispatcher,
+			replyOptions: params.replyOptions,
+			configOverride: params.configOverride
+		})
+	});
+}
+/** Assemble the common inbound reply dispatch dependencies for a resolved route. */
+function buildInboundReplyDispatchBase(params) {
+	return {
+		cfg: params.cfg,
+		channel: params.channel,
+		accountId: params.accountId,
+		agentId: params.route.agentId,
+		routeSessionKey: params.route.sessionKey,
+		storePath: params.storePath,
+		ctxPayload: params.ctxPayload,
+		recordInboundSession: params.core.channel.session.recordInboundSession,
+		dispatchReplyWithBufferedBlockDispatcher: params.core.channel.reply.dispatchReplyWithBufferedBlockDispatcher
+	};
+}
+/** Resolve the shared dispatch base and immediately record + dispatch one inbound reply turn. */
+async function dispatchInboundReplyWithBase(params) {
+	await recordInboundSessionAndDispatchReply({
+		...buildInboundReplyDispatchBase(params),
+		deliver: params.deliver,
+		onRecordError: params.onRecordError,
+		onDispatchError: params.onDispatchError,
+		replyOptions: params.replyOptions
+	});
+}
+/** Record the inbound session first, then dispatch the reply using normalized outbound delivery. */
+async function recordInboundSessionAndDispatchReply(params) {
+	await params.recordInboundSession({
+		storePath: params.storePath,
+		sessionKey: params.ctxPayload.SessionKey ?? params.routeSessionKey,
+		ctx: params.ctxPayload,
+		onRecordError: params.onRecordError
+	});
+	const { onModelSelected, ...replyPipeline } = createChannelReplyPipeline({
+		cfg: params.cfg,
+		agentId: params.agentId,
+		channel: params.channel,
+		accountId: params.accountId
+	});
+	const deliver = createNormalizedOutboundDeliverer(params.deliver);
+	await params.dispatchReplyWithBufferedBlockDispatcher({
+		ctx: params.ctxPayload,
+		cfg: params.cfg,
+		dispatcherOptions: {
+			...replyPipeline,
+			deliver,
+			onError: params.onDispatchError
+		},
+		replyOptions: {
+			...params.replyOptions,
+			onModelSelected
+		}
+	});
+}
+//#endregion
+export { recordInboundSessionAndDispatchReply as i, dispatchInboundReplyWithBase as n, dispatchReplyFromConfigWithSettledDispatcher as r, buildInboundReplyDispatchBase as t };

package/dist/index.js

@@ -27,7 +27,7 @@ let runExec;
 let saveSessionStore;
 let waitForever;
 async function loadLegacyCliDeps() {
-	const { runCli } = await import("./run-main-ROsTM9o9.js");
+	const { runCli } = await import("./run-main-xnrI4i-W.js");
 	return { runCli };
 }
 async function runLegacyCliEntry(argv = process.argv, deps) {
@@ -35,7 +35,7 @@ async function runLegacyCliEntry(argv = process.argv, deps) {
 	await runCli(argv);
 }
 const isMain = isMainModule({ currentFile: fileURLToPath(import.meta.url) });
-if (!isMain) ({applyTemplate, createDefaultDeps, deriveSessionKey, describePortOwner, ensureBinary, ensurePortAvailable, getReplyFromConfig, handlePortError, loadConfig, loadSessionStore, monitorWebChannel, normalizeE164, PortInUseError, promptYesNo, resolveSessionKey, resolveStorePath, runCommandWithTimeout, runExec, saveSessionStore, waitForever} = await import("./library-DFR5f_Ir.js"));
+if (!isMain) ({applyTemplate, createDefaultDeps, deriveSessionKey, describePortOwner, ensureBinary, ensurePortAvailable, getReplyFromConfig, handlePortError, loadConfig, loadSessionStore, monitorWebChannel, normalizeE164, PortInUseError, promptYesNo, resolveSessionKey, resolveStorePath, runCommandWithTimeout, runExec, saveSessionStore, waitForever} = await import("./library-mAKEzoAM.js"));
 if (isMain) {
 	const { restoreTerminalState } = await import("./restore-BI6Ocy0f.js");
 	installUnhandledRejectionHandler();

package/dist/infra-runtime-DwRkDuXF.js

@@ -0,0 +1,38 @@
+import "./errors-CufR9eHH.js";
+import "./env-DgbHOvMC.js";
+import "./file-lock-B_Mqlgsi.js";
+import "./ssrf-BR9EvI4i.js";
+import "./undici-global-dispatcher-BXAZ1WB7.js";
+import "./fetch-guard-CsgToyd0.js";
+import "./fs-safe-B265VM-X.js";
+import "./exec-approvals-D0DTIzDT.js";
+import "./system-events-DEhWwh94.js";
+import "./proxy-fetch-CC56jq2D.js";
+import { n as drainPendingDeliveries$1 } from "./delivery-queue-YQ1IDRS7.js";
+import "./retry-yozeJBm8.js";
+import "./secret-file-Bwm4cCSC.js";
+import "./http-body-C0x1hv3x.js";
+import "./exec-approval-reply-BhbjoK1B.js";
+import "./approval-native-runtime-C0zvGwfB.js";
+import "./exec-approval-command-display-DbllZxHW.js";
+import "./exec-approval-session-target-s7of6-Bw.js";
+import "./heartbeat-events-Bw8wnK9o.js";
+import "./transport-ready-fymwId31.js";
+import "./identity-B2OOV1ac.js";
+import "./retry-policy-CFXAWhji.js";
+import "./ssrf-policy-ChAc-ige.js";
+//#region src/plugin-sdk/infra-runtime.ts
+let outboundDeliverRuntimePromise = null;
+async function loadOutboundDeliverRuntime() {
+	outboundDeliverRuntimePromise ??= import("./deliver-runtime-DZlx42y2.js");
+	return await outboundDeliverRuntimePromise;
+}
+async function drainPendingDeliveries(opts) {
+	const deliver = opts.deliver ?? (await loadOutboundDeliverRuntime()).deliverOutboundPayloads;
+	await drainPendingDeliveries$1({
+		...opts,
+		deliver
+	});
+}
+//#endregion
+export { drainPendingDeliveries as t };

package/dist/init-DwpSUAfi.js

@@ -0,0 +1,59 @@
+import { r as registerContextEngineForOwner } from "./registry-D8vE-bbo.js";
+import { n as delegateCompactionToRuntime } from "./delegate-CBLxnP3N.js";
+//#region src/context-engine/legacy.ts
+/**
+* LegacyContextEngine wraps the existing compaction behavior behind the
+* ContextEngine interface, preserving 100% backward compatibility.
+*
+* - ingest: no-op (SessionManager handles message persistence)
+* - assemble: pass-through (existing sanitize/validate/limit pipeline in attempt.ts handles this)
+* - compact: delegates to compactEmbeddedPiSessionDirect
+*/
+var LegacyContextEngine = class {
+	constructor() {
+		this.info = {
+			id: "legacy",
+			name: "Legacy Context Engine",
+			version: "1.0.0"
+		};
+	}
+	async ingest(_params) {
+		return { ingested: false };
+	}
+	async assemble(params) {
+		return {
+			messages: params.messages,
+			estimatedTokens: 0
+		};
+	}
+	async afterTurn(_params) {}
+	async compact(params) {
+		return await delegateCompactionToRuntime(params);
+	}
+	async dispose() {}
+};
+//#endregion
+//#region src/context-engine/legacy.registration.ts
+function registerLegacyContextEngine() {
+	registerContextEngineForOwner("legacy", async () => new LegacyContextEngine(), "core", { allowSameOwnerRefresh: true });
+}
+//#endregion
+//#region src/context-engine/init.ts
+/**
+* Ensures all built-in context engines are registered exactly once.
+*
+* The legacy engine is always registered as a safe fallback so that
+* `resolveContextEngine()` can resolve the default "legacy" slot without
+* callers needing to remember manual registration.
+*
+* Additional engines are registered by their own plugins via
+* `api.registerContextEngine()` during plugin load.
+*/
+let initialized = false;
+function ensureContextEnginesInitialized() {
+	if (initialized) return;
+	initialized = true;
+	registerLegacyContextEngine();
+}
+//#endregion
+export { ensureContextEnginesInitialized as t };

package/dist/library-mAKEzoAM.js

@@ -0,0 +1,45 @@
+import { u as normalizeE164 } from "./utils-CWrkFsp0.js";
+import { a as loadConfig } from "./io-Cy5vajWd.js";
+import { i as handlePortError, n as describePortOwner, r as ensurePortAvailable, t as PortInUseError } from "./ports-C52nWpb8.js";
+import "./config-DYHZ3jG1.js";
+import { u as resolveStorePath } from "./paths-CiRFr3OE.js";
+import { t as loadSessionStore } from "./store-load-DLkfg3iM.js";
+import { i as saveSessionStore } from "./store-tuisxHpf.js";
+import { n as resolveSessionKey, t as deriveSessionKey } from "./session-key-CTestOWs.js";
+import { t as applyTemplate } from "./templating-BceL7QZ6.js";
+import { t as waitForever } from "./wait-CPwKGmXl.js";
+import { t as createDefaultDeps } from "./deps-CMhJYvQj.js";
+//#region src/library.ts
+let replyRuntimePromise = null;
+let promptRuntimePromise = null;
+let binariesRuntimePromise = null;
+let execRuntimePromise = null;
+let webChannelRuntimePromise = null;
+function loadReplyRuntime() {
+	replyRuntimePromise ??= import("./reply.runtime-CvlE6uYh.js");
+	return replyRuntimePromise;
+}
+function loadPromptRuntime() {
+	promptRuntimePromise ??= import("./prompt-Dwr5n5SM.js");
+	return promptRuntimePromise;
+}
+function loadBinariesRuntime() {
+	binariesRuntimePromise ??= import("./binaries-D8lCKoyq.js");
+	return binariesRuntimePromise;
+}
+function loadExecRuntime() {
+	execRuntimePromise ??= import("./exec-DKTtIuXV.js");
+	return execRuntimePromise;
+}
+function loadWebChannelRuntime() {
+	webChannelRuntimePromise ??= import("./runtime-web-channel-plugin-ChmPPl7a.js");
+	return webChannelRuntimePromise;
+}
+const getReplyFromConfig = async (...args) => (await loadReplyRuntime()).getReplyFromConfig(...args);
+const promptYesNo = async (...args) => (await loadPromptRuntime()).promptYesNo(...args);
+const ensureBinary = async (...args) => (await loadBinariesRuntime()).ensureBinary(...args);
+const runExec = async (...args) => (await loadExecRuntime()).runExec(...args);
+const runCommandWithTimeout = async (...args) => (await loadExecRuntime()).runCommandWithTimeout(...args);
+const monitorWebChannel = async (...args) => (await loadWebChannelRuntime()).monitorWebChannel(...args);
+//#endregion
+export { PortInUseError, applyTemplate, createDefaultDeps, deriveSessionKey, describePortOwner, ensureBinary, ensurePortAvailable, getReplyFromConfig, handlePortError, loadConfig, loadSessionStore, monitorWebChannel, normalizeE164, promptYesNo, resolveSessionKey, resolveStorePath, runCommandWithTimeout, runExec, saveSessionStore, waitForever };

package/dist/lifecycle-BUTglQLK.js

@@ -0,0 +1,229 @@
+import { c as normalizeOptionalString } from "./string-coerce-DPP_aYVc.js";
+import { n as defaultRuntime } from "./runtime-DDkDH9fa.js";
+import { r as theme } from "./theme-DD6pQv2_.js";
+import { t as formatCliCommand } from "./command-format-B3Q5KD9o.js";
+import { u as resolveGatewayPort } from "./paths-Bv2rGpO9.js";
+import { l as readBestEffortConfig } from "./io-Cy5vajWd.js";
+import { i as launchAgentPlistExists, s as repairLaunchAgentBootstrap } from "./launchd-BkMiQmu-.js";
+import { d as formatGatewayPidList, f as signalVerifiedGatewayPidSync, u as findVerifiedGatewayListenerPidsOnPortSync } from "./schtasks-PNDMVAhu.js";
+import { r as resolveGatewayService } from "./service-DiHWY6iI.js";
+import { l as renderGatewayServiceStartHints, s as parsePortFromArgs } from "./shared-Bes_qipP.js";
+import { r as isRestartEnabled } from "./commands.flags-CIvSlgUV.js";
+import "./config-DYHZ3jG1.js";
+import { a as probeGateway } from "./probe-CDrkDwhe.js";
+import { i as runServiceUninstall, n as runServiceStart, r as runServiceStop, t as runServiceRestart } from "./lifecycle-core-CIojLR-Y.js";
+import { a as renderGatewayPortHealthDiagnostics, c as waitForGatewayHealthyListener, l as waitForGatewayHealthyRestart, o as renderRestartDiagnostics, s as terminateStaleGatewayPids, t as DEFAULT_RESTART_HEALTH_ATTEMPTS } from "./restart-health-CV-Nm1lw.js";
+//#region src/cli/daemon-cli/launchd-recovery.ts
+const LAUNCH_AGENT_RECOVERY_MESSAGE = "Gateway LaunchAgent was installed but not loaded; re-bootstrapped launchd service.";
+async function recoverInstalledLaunchAgent(params) {
+	if (process.platform !== "darwin") return null;
+	const env = params.env ?? process.env;
+	if (!await launchAgentPlistExists(env).catch(() => false)) return null;
+	if (!(await repairLaunchAgentBootstrap({ env }).catch(() => ({
+		ok: false,
+		status: "bootstrap-failed"
+	}))).ok) return null;
+	return {
+		result: params.result,
+		loaded: true,
+		message: LAUNCH_AGENT_RECOVERY_MESSAGE
+	};
+}
+//#endregion
+//#region src/cli/daemon-cli/lifecycle.ts
+const POST_RESTART_HEALTH_ATTEMPTS = DEFAULT_RESTART_HEALTH_ATTEMPTS;
+const POST_RESTART_HEALTH_DELAY_MS = 500;
+const WINDOWS_POST_RESTART_HEALTH_TIMEOUT_MS = 18e4;
+function postRestartHealthAttempts() {
+	return process.platform === "win32" ? Math.ceil(WINDOWS_POST_RESTART_HEALTH_TIMEOUT_MS / POST_RESTART_HEALTH_DELAY_MS) : POST_RESTART_HEALTH_ATTEMPTS;
+}
+function formatRestartFailure(params) {
+	if (params.health.waitOutcome === "stopped-free") {
+		const elapsedSeconds = Math.max(1, Math.round((params.health.elapsedMs ?? 0) / 1e3));
+		return {
+			statusLine: `Gateway restart failed after ${elapsedSeconds}s: service stayed stopped and port ${params.port} stayed free.`,
+			failMessage: `Gateway restart failed after ${elapsedSeconds}s: service stayed stopped and health checks never came up.`
+		};
+	}
+	return {
+		statusLine: `Timed out after ${params.timeoutSeconds}s waiting for gateway port ${params.port} to become healthy.`,
+		failMessage: `Gateway restart timed out after ${params.timeoutSeconds}s waiting for health checks.`
+	};
+}
+async function resolveGatewayLifecyclePort(service = resolveGatewayService()) {
+	const command = await service.readCommand(process.env).catch(() => null);
+	const serviceEnv = command?.environment ?? void 0;
+	const mergedEnv = {
+		...process.env,
+		...serviceEnv ?? void 0
+	};
+	return parsePortFromArgs(command?.programArguments) ?? resolveGatewayPort(await readBestEffortConfig(), mergedEnv);
+}
+function resolveGatewayPortFallback() {
+	return readBestEffortConfig().then((cfg) => resolveGatewayPort(cfg, process.env)).catch(() => resolveGatewayPort(void 0, process.env));
+}
+async function assertUnmanagedGatewayRestartEnabled(port) {
+	const probe = await probeGateway({
+		url: `${!!(await readBestEffortConfig().catch(() => void 0))?.gateway?.tls?.enabled ? "wss" : "ws"}://127.0.0.1:${port}`,
+		auth: {
+			token: normalizeOptionalString(process.env.GENESIS_GATEWAY_TOKEN),
+			password: normalizeOptionalString(process.env.GENESIS_GATEWAY_PASSWORD)
+		},
+		timeoutMs: 1e3
+	}).catch(() => null);
+	if (!probe?.ok) return;
+	if (!isRestartEnabled(probe.configSnapshot)) throw new Error("Gateway restart is disabled in the running gateway config (commands.restart=false); unmanaged SIGUSR1 restart would be ignored");
+}
+function resolveVerifiedGatewayListenerPids(port) {
+	return findVerifiedGatewayListenerPidsOnPortSync(port).filter((pid) => Number.isFinite(pid) && pid > 0);
+}
+async function stopGatewayWithoutServiceManager(port) {
+	const pids = resolveVerifiedGatewayListenerPids(port);
+	if (pids.length === 0) return null;
+	for (const pid of pids) signalVerifiedGatewayPidSync(pid, "SIGTERM");
+	return {
+		result: "stopped",
+		message: `Gateway stop signal sent to unmanaged process${pids.length === 1 ? "" : "es"} on port ${port}: ${formatGatewayPidList(pids)}.`
+	};
+}
+async function restartGatewayWithoutServiceManager(port) {
+	await assertUnmanagedGatewayRestartEnabled(port);
+	const pids = resolveVerifiedGatewayListenerPids(port);
+	if (pids.length === 0) return null;
+	if (pids.length > 1) throw new Error(`multiple gateway processes are listening on port ${port}: ${formatGatewayPidList(pids)}; use "genesis gateway status --deep" before retrying restart`);
+	signalVerifiedGatewayPidSync(pids[0], "SIGUSR1");
+	return {
+		result: "restarted",
+		message: `Gateway restart signal sent to unmanaged process on port ${port}: ${pids[0]}.`
+	};
+}
+async function runDaemonUninstall(opts = {}) {
+	return await runServiceUninstall({
+		serviceNoun: "Gateway",
+		service: resolveGatewayService(),
+		opts,
+		stopBeforeUninstall: true,
+		assertNotLoadedAfterUninstall: true
+	});
+}
+async function runDaemonStart(opts = {}) {
+	return await runServiceStart({
+		serviceNoun: "Gateway",
+		service: resolveGatewayService(),
+		renderStartHints: renderGatewayServiceStartHints,
+		onNotLoaded: process.platform === "darwin" ? async () => await recoverInstalledLaunchAgent({ result: "started" }) : void 0,
+		opts
+	});
+}
+async function runDaemonStop(opts = {}) {
+	const service = resolveGatewayService();
+	let gatewayPortPromise;
+	return await runServiceStop({
+		serviceNoun: "Gateway",
+		service,
+		opts,
+		onNotLoaded: async () => {
+			gatewayPortPromise ??= resolveGatewayLifecyclePort(service).catch(() => resolveGatewayPortFallback());
+			return await stopGatewayWithoutServiceManager(await gatewayPortPromise);
+		}
+	});
+}
+/**
+* Restart the gateway service service.
+* @returns `true` if restart succeeded, `false` if the service was not loaded.
+* Throws/exits on check or restart failures.
+*/
+async function runDaemonRestart(opts = {}) {
+	const json = Boolean(opts.json);
+	const service = resolveGatewayService();
+	let restartedWithoutServiceManager = false;
+	const restartPort = await resolveGatewayLifecyclePort(service).catch(() => resolveGatewayPortFallback());
+	const restartHealthAttempts = postRestartHealthAttempts();
+	const restartWaitMs = restartHealthAttempts * POST_RESTART_HEALTH_DELAY_MS;
+	const restartWaitSeconds = Math.round(restartWaitMs / 1e3);
+	return await runServiceRestart({
+		serviceNoun: "Gateway",
+		service,
+		renderStartHints: renderGatewayServiceStartHints,
+		opts,
+		checkTokenDrift: true,
+		onNotLoaded: async () => {
+			const handled = await restartGatewayWithoutServiceManager(restartPort);
+			if (handled) {
+				restartedWithoutServiceManager = true;
+				return handled;
+			}
+			return await recoverInstalledLaunchAgent({ result: "restarted" });
+		},
+		postRestartCheck: async ({ warnings, fail, stdout }) => {
+			if (restartedWithoutServiceManager) {
+				const health = await waitForGatewayHealthyListener({
+					port: restartPort,
+					attempts: restartHealthAttempts,
+					delayMs: POST_RESTART_HEALTH_DELAY_MS
+				});
+				if (health.healthy) return;
+				const diagnostics = renderGatewayPortHealthDiagnostics(health);
+				const timeoutLine = `Timed out after ${restartWaitSeconds}s waiting for gateway port ${restartPort} to become healthy.`;
+				if (!json) {
+					defaultRuntime.log(theme.warn(timeoutLine));
+					for (const line of diagnostics) defaultRuntime.log(theme.muted(line));
+				} else {
+					warnings.push(timeoutLine);
+					warnings.push(...diagnostics);
+				}
+				fail(`Gateway restart timed out after ${restartWaitSeconds}s waiting for health checks.`, [formatCliCommand("genesis gateway status --deep"), formatCliCommand("genesis doctor")]);
+				throw new Error("unreachable after gateway restart health failure");
+			}
+			let health = await waitForGatewayHealthyRestart({
+				service,
+				port: restartPort,
+				attempts: restartHealthAttempts,
+				delayMs: POST_RESTART_HEALTH_DELAY_MS,
+				includeUnknownListenersAsStale: process.platform === "win32"
+			});
+			if (!health.healthy && health.staleGatewayPids.length > 0) {
+				const staleMsg = `Found stale gateway process(es): ${health.staleGatewayPids.join(", ")}.`;
+				warnings.push(staleMsg);
+				if (!json) {
+					defaultRuntime.log(theme.warn(staleMsg));
+					defaultRuntime.log(theme.muted("Stopping stale process(es) and retrying restart..."));
+				}
+				await terminateStaleGatewayPids(health.staleGatewayPids);
+				const retryRestart = await service.restart({
+					env: process.env,
+					stdout
+				});
+				if (retryRestart.outcome === "scheduled") return retryRestart;
+				health = await waitForGatewayHealthyRestart({
+					service,
+					port: restartPort,
+					attempts: restartHealthAttempts,
+					delayMs: POST_RESTART_HEALTH_DELAY_MS,
+					includeUnknownListenersAsStale: process.platform === "win32"
+				});
+			}
+			if (health.healthy) return;
+			const diagnostics = renderRestartDiagnostics(health);
+			const failure = formatRestartFailure({
+				health,
+				port: restartPort,
+				timeoutSeconds: restartWaitSeconds
+			});
+			const runningNoPortLine = health.runtime.status === "running" && health.portUsage.status === "free" ? `Gateway process is running but port ${restartPort} is still free (startup hang/crash loop or very slow VM startup).` : null;
+			if (!json) {
+				defaultRuntime.log(theme.warn(failure.statusLine));
+				if (runningNoPortLine) defaultRuntime.log(theme.warn(runningNoPortLine));
+				for (const line of diagnostics) defaultRuntime.log(theme.muted(line));
+			} else {
+				warnings.push(failure.statusLine);
+				if (runningNoPortLine) warnings.push(runningNoPortLine);
+				warnings.push(...diagnostics);
+			}
+			fail(failure.failMessage, [formatCliCommand("genesis gateway status --deep"), formatCliCommand("genesis doctor")]);
+			throw new Error("unreachable after gateway restart failure");
+		}
+	});
+}
+//#endregion
+export { runDaemonUninstall as i, runDaemonStart as n, runDaemonStop as r, runDaemonRestart as t };