@pixelzx/genesis 2026.5.3-5 → 2026.5.5

package/dist/status-p4yx6E3C.js

@@ -0,0 +1,209 @@
+import { _ as shortenHomePath } from "./utils-DaGfogP-.js";
+import { n as defaultRuntime } from "./runtime-CQ7eH0le.js";
+import { n as isRich, r as theme, t as colorize } from "./theme-BrRleVfL.js";
+import { t as formatCliCommand } from "./command-format-DAeUlu7u.js";
+import { d as resolveGatewayLaunchAgentLabel, p as resolveGatewaySystemdServiceName } from "./paths-Dk_PxD7g.js";
+import { i as resolveGatewayRestartLogPath, r as resolveGatewayLogPaths } from "./restart-logs-D-iNn94A.js";
+import { p as classifySystemdUnavailableDetail } from "./systemd-BmENWaxT.js";
+import { a as filterDaemonEnv, d as resolveRuntimeStatusColor, f as safeDaemonEnv, t as createCliStatusTextStyles, u as renderRuntimeHints } from "./shared-BdZN5DvO.js";
+import { i as resolveDaemonContainerContext, r as formatRuntimeStatus } from "./runtime-hints-U-UR-C6L.js";
+import { t as formatConfigIssueLine } from "./issue-format-CctGyTV-.js";
+import { n as renderSystemdUnavailableHints, t as isSystemdUnavailableDetail } from "./systemd-hints-CJxKhtPZ.js";
+import { r as isWSLEnv } from "./wsl-Be1oClcA.js";
+import { n as renderPortDiagnosticsForCli, r as resolvePortListeningAddresses, t as gatherDaemonStatus } from "./status.gather-B7WlHpIR.js";
+import { r as renderGatewayServiceCleanupHints } from "./inspect-LwBiIJzN.js";
+import { t as resolveControlUiLinks } from "./control-ui-links-BvGEIgO7.js";
+//#region src/cli/daemon-cli/status.print.ts
+function sanitizeDaemonStatusForJson(status) {
+	const command = status.service.command;
+	if (!command?.environment) return status;
+	const safeEnv = filterDaemonEnv(command.environment);
+	const nextCommand = {
+		...command,
+		environment: Object.keys(safeEnv).length > 0 ? safeEnv : void 0
+	};
+	return {
+		...status,
+		service: {
+			...status.service,
+			command: nextCommand
+		}
+	};
+}
+function formatProbeKindLabel(kind) {
+	return kind === "read" ? "Read probe:" : "Connectivity probe:";
+}
+function formatCapabilityLabel(capability) {
+	if (!capability) return null;
+	return capability.replaceAll("_", "-");
+}
+function printDaemonStatus(status, opts) {
+	if (opts.json) {
+		const sanitized = sanitizeDaemonStatusForJson(status);
+		defaultRuntime.writeJson(sanitized);
+		return;
+	}
+	const { rich, label, accent, infoText, okText, warnText, errorText } = createCliStatusTextStyles();
+	const spacer = () => defaultRuntime.log("");
+	const { service, rpc, extraServices } = status;
+	const serviceStatus = service.loaded ? okText(service.loadedText) : warnText(service.notLoadedText);
+	defaultRuntime.log(`${label("Service:")} ${accent(service.label)} (${serviceStatus})`);
+	if (status.logFile) defaultRuntime.log(`${label("File logs:")} ${infoText(shortenHomePath(status.logFile))}`);
+	if (service.command?.programArguments?.length) defaultRuntime.log(`${label("Command:")} ${infoText(service.command.programArguments.join(" "))}`);
+	if (service.command?.sourcePath) defaultRuntime.log(`${label("Service file:")} ${infoText(shortenHomePath(service.command.sourcePath))}`);
+	if (service.command?.workingDirectory) defaultRuntime.log(`${label("Working dir:")} ${infoText(shortenHomePath(service.command.workingDirectory))}`);
+	const daemonEnvLines = safeDaemonEnv(service.command?.environment);
+	if (daemonEnvLines.length > 0) defaultRuntime.log(`${label("Service env:")} ${daemonEnvLines.join(" ")}`);
+	spacer();
+	if (service.configAudit?.issues.length) {
+		defaultRuntime.error(warnText("Service config looks out of date or non-standard."));
+		for (const issue of service.configAudit.issues) {
+			const detail = issue.detail ? ` (${issue.detail})` : "";
+			defaultRuntime.error(`${warnText("Service config issue:")} ${issue.message}${detail}`);
+		}
+		defaultRuntime.error(warnText(`Recommendation: run "${formatCliCommand("genesis doctor")}" (or "${formatCliCommand("genesis doctor --repair")}").`));
+	}
+	if (status.config) {
+		const cliCfg = `${shortenHomePath(status.config.cli.path)}${status.config.cli.exists ? "" : " (missing)"}${status.config.cli.valid ? "" : " (invalid)"}`;
+		defaultRuntime.log(`${label("Config (cli):")} ${infoText(cliCfg)}`);
+		if (!status.config.cli.valid && status.config.cli.issues?.length) for (const issue of status.config.cli.issues.slice(0, 5)) defaultRuntime.error(`${errorText("Config issue:")} ${formatConfigIssueLine(issue, "", { normalizeRoot: true })}`);
+		if (status.config.daemon) {
+			const daemonCfg = `${shortenHomePath(status.config.daemon.path)}${status.config.daemon.exists ? "" : " (missing)"}${status.config.daemon.valid ? "" : " (invalid)"}`;
+			defaultRuntime.log(`${label("Config (service):")} ${infoText(daemonCfg)}`);
+			if (!status.config.daemon.valid && status.config.daemon.issues?.length) for (const issue of status.config.daemon.issues.slice(0, 5)) defaultRuntime.error(`${errorText("Service config issue:")} ${formatConfigIssueLine(issue, "", { normalizeRoot: true })}`);
+		}
+		if (status.config.mismatch) {
+			defaultRuntime.error(errorText("Root cause: CLI and service are using different config paths (likely a profile/state-dir mismatch)."));
+			defaultRuntime.error(errorText(`Fix: rerun \`${formatCliCommand("genesis gateway install --force")}\` from the same --profile / GENESIS_STATE_DIR you expect.`));
+		}
+		spacer();
+	}
+	if (status.gateway) {
+		const bindHost = status.gateway.bindHost ?? "n/a";
+		defaultRuntime.log(`${label("Gateway:")} bind=${infoText(status.gateway.bindMode)} (${infoText(bindHost)}), port=${infoText(String(status.gateway.port))} (${infoText(status.gateway.portSource)})`);
+		defaultRuntime.log(`${label("Probe target:")} ${infoText(status.gateway.probeUrl)}`);
+		if (!(status.config?.daemon?.controlUi?.enabled ?? true)) defaultRuntime.log(`${label("Dashboard:")} ${warnText("disabled")}`);
+		else {
+			const links = resolveControlUiLinks({
+				port: status.gateway.port,
+				bind: status.gateway.bindMode,
+				customBindHost: status.gateway.customBindHost,
+				basePath: status.config?.daemon?.controlUi?.basePath
+			});
+			defaultRuntime.log(`${label("Dashboard:")} ${infoText(links.httpUrl)}`);
+		}
+		if (status.gateway.probeNote) defaultRuntime.log(`${label("Probe note:")} ${infoText(status.gateway.probeNote)}`);
+		spacer();
+	}
+	const runtimeLine = formatRuntimeStatus(service.runtime);
+	if (runtimeLine) {
+		const runtimeColor = resolveRuntimeStatusColor(service.runtime?.status);
+		defaultRuntime.log(`${label("Runtime:")} ${colorize(rich, runtimeColor, runtimeLine)}`);
+	}
+	if (rpc && !rpc.ok && service.loaded && service.runtime?.status === "running") defaultRuntime.log(warnText("Warm-up: launch agents can take a few seconds. Try again shortly."));
+	if (rpc) {
+		const probeLabel = formatProbeKindLabel(rpc.kind);
+		if (rpc.ok) defaultRuntime.log(`${label(probeLabel)} ${okText("ok")}`);
+		else {
+			defaultRuntime.error(`${label(probeLabel)} ${errorText("failed")}`);
+			if (rpc.authWarning) defaultRuntime.error(`${label("Probe auth:")} ${warnText(rpc.authWarning)}`);
+			if (rpc.url) defaultRuntime.error(`${label("Probe target:")} ${rpc.url}`);
+			const lines = (rpc.error ?? "unknown").split(/\r?\n/).filter(Boolean);
+			for (const line of lines.slice(0, 12)) defaultRuntime.error(`  ${errorText(line)}`);
+		}
+		const capability = formatCapabilityLabel(rpc.capability);
+		if (capability) defaultRuntime.log(`${label("Capability:")} ${infoText(capability)}`);
+		spacer();
+	}
+	if (status.health && status.health.staleGatewayPids.length > 0 && service.runtime?.status === "running" && typeof service.runtime.pid === "number") {
+		defaultRuntime.error(errorText(`Gateway runtime PID does not own the listening port. Other gateway process(es) are listening: ${status.health.staleGatewayPids.join(", ")}`));
+		defaultRuntime.error(errorText(`Fix: run ${formatCliCommand("genesis gateway restart")} and re-check with ${formatCliCommand("genesis gateway status --deep")}.`));
+		spacer();
+	}
+	if (process.platform === "linux" && isSystemdUnavailableDetail(service.runtime?.detail)) {
+		const container = Boolean(resolveDaemonContainerContext(service.command?.environment ?? process.env));
+		defaultRuntime.error(errorText("systemd user services unavailable."));
+		for (const hint of renderSystemdUnavailableHints({
+			wsl: isWSLEnv(),
+			kind: classifySystemdUnavailableDetail(service.runtime?.detail),
+			container
+		})) defaultRuntime.error(errorText(hint));
+		spacer();
+	}
+	if (service.runtime?.missingUnit) {
+		defaultRuntime.error(errorText("Service unit not found."));
+		for (const hint of renderRuntimeHints(service.runtime, process.env, status.logFile)) defaultRuntime.error(errorText(hint));
+	} else if (service.loaded && service.runtime?.status === "stopped") {
+		defaultRuntime.error(errorText("Service is loaded but not running (likely exited immediately)."));
+		for (const hint of renderRuntimeHints(service.runtime, service.command?.environment ?? process.env, status.logFile)) defaultRuntime.error(errorText(hint));
+		spacer();
+	}
+	if (service.runtime?.cachedLabel) {
+		const labelValue = resolveGatewayLaunchAgentLabel((service.command?.environment ?? process.env).GENESIS_PROFILE);
+		defaultRuntime.error(errorText(`LaunchAgent label cached but plist missing. Clear with: launchctl bootout gui/$UID/${labelValue}`));
+		defaultRuntime.error(errorText(`Then reinstall: ${formatCliCommand("genesis gateway install")}`));
+		spacer();
+	}
+	for (const line of renderPortDiagnosticsForCli(status, rpc?.ok)) defaultRuntime.error(errorText(line));
+	if (status.port) {
+		const addrs = resolvePortListeningAddresses(status);
+		if (addrs.length > 0) defaultRuntime.log(`${label("Listening:")} ${infoText(addrs.join(", "))}`);
+	}
+	if (status.portCli && status.portCli.port !== status.port?.port) defaultRuntime.log(`${label("Note:")} CLI config resolves gateway port=${status.portCli.port} (${status.portCli.status}).`);
+	if (service.loaded && service.runtime?.status === "running" && status.port && status.port.status !== "busy") {
+		defaultRuntime.error(errorText(`Gateway port ${status.port.port} is not listening (service appears running).`));
+		const serviceEnv = {
+			...process.env,
+			...service.command?.environment
+		};
+		if (status.lastError) defaultRuntime.error(`${errorText("Last gateway error:")} ${status.lastError}`);
+		if (process.platform === "linux") {
+			const unit = resolveGatewaySystemdServiceName(serviceEnv.GENESIS_PROFILE);
+			defaultRuntime.error(errorText(`Logs: journalctl --user -u ${unit}.service -n 200 --no-pager`));
+		} else if (process.platform === "darwin") {
+			const logs = resolveGatewayLogPaths(serviceEnv);
+			defaultRuntime.error(`${errorText("Logs:")} ${shortenHomePath(logs.stdoutPath)}`);
+			defaultRuntime.error(`${errorText("Errors:")} ${shortenHomePath(logs.stderrPath)}`);
+		}
+		defaultRuntime.error(`${errorText("Restart log:")} ${shortenHomePath(resolveGatewayRestartLogPath(serviceEnv))}`);
+		spacer();
+	}
+	if (extraServices.length > 0) {
+		defaultRuntime.error(errorText("Other gateway-like services detected (best effort):"));
+		for (const svc of extraServices) defaultRuntime.error(`- ${errorText(svc.label)} (${svc.scope}, ${svc.detail})`);
+		for (const hint of renderGatewayServiceCleanupHints()) defaultRuntime.error(`${errorText("Cleanup hint:")} ${hint}`);
+		spacer();
+	}
+	if (extraServices.length > 0) {
+		defaultRuntime.error(errorText("Recommendation: run a single gateway per machine for most setups. One gateway supports multiple agents (see docs: /gateway#multiple-gateways-same-host)."));
+		defaultRuntime.error(errorText("If you need multiple gateways (e.g., a rescue bot on the same host), isolate ports + config/state (see docs: /gateway#multiple-gateways-same-host)."));
+		spacer();
+	}
+	defaultRuntime.log(`${label("Troubles:")} run ${formatCliCommand("genesis status")}`);
+	defaultRuntime.log(`${label("Troubleshooting:")} https://docs.genesis.ai/troubleshooting`);
+}
+//#endregion
+//#region src/cli/daemon-cli/status.ts
+async function runDaemonStatus(opts) {
+	try {
+		if (opts.requireRpc && !opts.probe) {
+			defaultRuntime.error("Gateway status failed: --require-rpc cannot be used with --no-probe.");
+			defaultRuntime.exit(1);
+			return;
+		}
+		const status = await gatherDaemonStatus({
+			rpc: opts.rpc,
+			probe: opts.probe,
+			requireRpc: opts.requireRpc,
+			deep: opts.deep === true
+		});
+		printDaemonStatus(status, { json: opts.json });
+		if (opts.requireRpc && !status.rpc?.ok) defaultRuntime.exit(1);
+	} catch (err) {
+		const rich = isRich();
+		defaultRuntime.error(colorize(rich, theme.error, `Gateway status failed: ${String(err)}`));
+		defaultRuntime.exit(1);
+	}
+}
+//#endregion
+export { runDaemonStatus as t };

package/dist/status-runtime-shared-yrzbsOR8.js

@@ -0,0 +1,257 @@
+import { n as readGatewayServiceState, r as resolveGatewayService } from "./service-ChLFBF7Q.js";
+import { n as resolveReadOnlyChannelPluginsForConfig } from "./read-only-Bc9RJswo.js";
+import { t as resolveNodeService } from "./node-service-CijQCPXW.js";
+import { a as buildStatusOverviewSurfaceRows, t as buildGatewayStatusJsonPayload } from "./format-CDtdyx29.js";
+import { t as formatDaemonRuntimeShort } from "./status.format-W7wEx1Nr.js";
+//#region src/commands/status-overview-surface.ts
+function buildStatusOverviewSurfaceFromScan(params) {
+	return {
+		cfg: params.scan.cfg,
+		update: params.scan.update,
+		tailscaleMode: params.scan.tailscaleMode,
+		tailscaleDns: params.scan.tailscaleDns,
+		tailscaleHttpsUrl: params.scan.tailscaleHttpsUrl,
+		gatewayMode: params.scan.gatewayMode,
+		remoteUrlMissing: params.scan.remoteUrlMissing,
+		gatewayConnection: params.scan.gatewayConnection,
+		gatewayReachable: params.scan.gatewayReachable,
+		gatewayProbe: params.scan.gatewayProbe,
+		gatewayProbeAuth: params.scan.gatewayProbeAuth,
+		gatewayProbeAuthWarning: params.scan.gatewayProbeAuthWarning,
+		gatewaySelf: params.scan.gatewaySelf,
+		gatewayService: params.gatewayService,
+		nodeService: params.nodeService,
+		nodeOnlyGateway: params.nodeOnlyGateway
+	};
+}
+function buildStatusOverviewSurfaceFromOverview(params) {
+	return {
+		cfg: params.overview.cfg,
+		update: params.overview.update,
+		tailscaleMode: params.overview.tailscaleMode,
+		tailscaleDns: params.overview.tailscaleDns,
+		tailscaleHttpsUrl: params.overview.tailscaleHttpsUrl,
+		gatewayMode: params.overview.gatewaySnapshot.gatewayMode,
+		remoteUrlMissing: params.overview.gatewaySnapshot.remoteUrlMissing,
+		gatewayConnection: params.overview.gatewaySnapshot.gatewayConnection,
+		gatewayReachable: params.overview.gatewaySnapshot.gatewayReachable,
+		gatewayProbe: params.overview.gatewaySnapshot.gatewayProbe,
+		gatewayProbeAuth: params.overview.gatewaySnapshot.gatewayProbeAuth,
+		gatewayProbeAuthWarning: params.overview.gatewaySnapshot.gatewayProbeAuthWarning,
+		gatewaySelf: params.overview.gatewaySnapshot.gatewaySelf,
+		gatewayService: params.gatewayService,
+		nodeService: params.nodeService,
+		nodeOnlyGateway: params.nodeOnlyGateway
+	};
+}
+function buildStatusOverviewRowsFromSurface(params) {
+	return buildStatusOverviewSurfaceRows({
+		cfg: params.surface.cfg,
+		update: params.surface.update,
+		tailscaleMode: params.surface.tailscaleMode,
+		tailscaleDns: params.surface.tailscaleDns,
+		tailscaleHttpsUrl: params.surface.tailscaleHttpsUrl,
+		tailscaleBackendState: params.tailscaleBackendState,
+		includeBackendStateWhenOff: params.includeBackendStateWhenOff,
+		includeBackendStateWhenOn: params.includeBackendStateWhenOn,
+		includeDnsNameWhenOff: params.includeDnsNameWhenOff,
+		decorateTailscaleOff: params.decorateTailscaleOff,
+		decorateTailscaleWarn: params.decorateTailscaleWarn,
+		gatewayMode: params.surface.gatewayMode,
+		remoteUrlMissing: params.surface.remoteUrlMissing,
+		gatewayConnection: params.surface.gatewayConnection,
+		gatewayReachable: params.surface.gatewayReachable,
+		gatewayProbe: params.surface.gatewayProbe,
+		gatewayProbeAuth: params.surface.gatewayProbeAuth,
+		gatewayProbeAuthWarning: params.surface.gatewayProbeAuthWarning,
+		gatewaySelf: params.surface.gatewaySelf,
+		gatewayService: params.surface.gatewayService,
+		nodeService: params.surface.nodeService,
+		nodeOnlyGateway: params.surface.nodeOnlyGateway,
+		decorateOk: params.decorateOk,
+		decorateWarn: params.decorateWarn,
+		prefixRows: params.prefixRows,
+		middleRows: params.middleRows,
+		suffixRows: params.suffixRows,
+		agentsValue: params.agentsValue,
+		updateValue: params.updateValue,
+		gatewayAuthWarningValue: params.gatewayAuthWarningValue,
+		gatewaySelfFallbackValue: params.gatewaySelfFallbackValue
+	});
+}
+function buildStatusGatewayJsonPayloadFromSurface(params) {
+	return buildGatewayStatusJsonPayload({
+		gatewayMode: params.surface.gatewayMode,
+		gatewayConnection: params.surface.gatewayConnection,
+		remoteUrlMissing: params.surface.remoteUrlMissing,
+		gatewayReachable: params.surface.gatewayReachable,
+		gatewayProbe: params.surface.gatewayProbe,
+		gatewaySelf: params.surface.gatewaySelf,
+		gatewayProbeAuthWarning: params.surface.gatewayProbeAuthWarning
+	});
+}
+//#endregion
+//#region src/commands/status.service-summary.ts
+async function readServiceStatusSummary(service, fallbackLabel) {
+	try {
+		const state = await readGatewayServiceState(service, { env: process.env });
+		const managedByGenesis = state.installed;
+		const externallyManaged = !managedByGenesis && state.running;
+		const installed = managedByGenesis || externallyManaged;
+		const loadedText = externallyManaged ? "running (externally managed)" : state.loaded ? service.loadedText : service.notLoadedText;
+		return {
+			label: service.label,
+			installed,
+			loaded: state.loaded,
+			managedByGenesis,
+			externallyManaged,
+			loadedText,
+			runtime: state.runtime
+		};
+	} catch {
+		return {
+			label: fallbackLabel,
+			installed: null,
+			loaded: false,
+			managedByGenesis: false,
+			externallyManaged: false,
+			loadedText: "unknown",
+			runtime: void 0
+		};
+	}
+}
+//#endregion
+//#region src/commands/status.daemon.ts
+async function buildDaemonStatusSummary(serviceLabel) {
+	const summary = await readServiceStatusSummary(serviceLabel === "gateway" ? resolveGatewayService() : resolveNodeService(), serviceLabel === "gateway" ? "Daemon" : "Node");
+	return {
+		label: summary.label,
+		installed: summary.installed,
+		loaded: summary.loaded,
+		managedByGenesis: summary.managedByGenesis,
+		externallyManaged: summary.externallyManaged,
+		loadedText: summary.loadedText,
+		runtime: summary.runtime,
+		runtimeShort: formatDaemonRuntimeShort(summary.runtime)
+	};
+}
+async function getDaemonStatusSummary() {
+	return await buildDaemonStatusSummary("gateway");
+}
+async function getNodeDaemonStatusSummary() {
+	return await buildDaemonStatusSummary("node");
+}
+//#endregion
+//#region src/commands/status-runtime-shared.ts
+let providerUsagePromise;
+let securityAuditModulePromise;
+let gatewayCallModulePromise;
+function loadProviderUsage() {
+	providerUsagePromise ??= import("./provider-usage-DZHssxuZ.js");
+	return providerUsagePromise;
+}
+function loadSecurityAuditModule() {
+	securityAuditModulePromise ??= import("./audit.runtime-C7n442Rc.js");
+	return securityAuditModulePromise;
+}
+function loadGatewayCallModule() {
+	gatewayCallModulePromise ??= import("./call-Ckws4Nlw.js");
+	return gatewayCallModulePromise;
+}
+async function resolveStatusSecurityAudit(params) {
+	const { runSecurityAudit } = await loadSecurityAuditModule();
+	const readOnlyPlugins = resolveReadOnlyChannelPluginsForConfig(params.config, { activationSourceConfig: params.sourceConfig });
+	return await runSecurityAudit({
+		config: params.config,
+		sourceConfig: params.sourceConfig,
+		deep: false,
+		includeFilesystem: true,
+		includeChannelSecurity: true,
+		...readOnlyPlugins.missingConfiguredChannelIds.length === 0 ? { plugins: readOnlyPlugins.plugins } : {}
+	});
+}
+async function resolveStatusUsageSummary(timeoutMs) {
+	const { loadProviderUsageSummary } = await loadProviderUsage();
+	return await loadProviderUsageSummary({ timeoutMs });
+}
+async function loadStatusProviderUsageModule() {
+	return await loadProviderUsage();
+}
+async function resolveStatusGatewayHealth(params) {
+	const { callGateway } = await loadGatewayCallModule();
+	return await callGateway({
+		method: "health",
+		params: { probe: true },
+		timeoutMs: params.timeoutMs,
+		config: params.config
+	});
+}
+async function resolveStatusGatewayHealthSafe(params) {
+	if (!params.gatewayReachable) return { error: params.gatewayProbeError ?? "gateway unreachable" };
+	const { callGateway } = await loadGatewayCallModule();
+	return await callGateway({
+		method: "health",
+		params: { probe: true },
+		timeoutMs: params.timeoutMs,
+		config: params.config,
+		...params.callOverrides
+	}).catch((err) => ({ error: String(err) }));
+}
+async function resolveStatusLastHeartbeat(params) {
+	if (!params.gatewayReachable) return null;
+	const { callGateway } = await loadGatewayCallModule();
+	return await callGateway({
+		method: "last-heartbeat",
+		params: {},
+		timeoutMs: params.timeoutMs,
+		config: params.config
+	}).catch(() => null);
+}
+async function resolveStatusServiceSummaries() {
+	return await Promise.all([getDaemonStatusSummary(), getNodeDaemonStatusSummary()]);
+}
+async function resolveStatusRuntimeDetails(params) {
+	const resolveUsageSummary = params.resolveUsage ?? resolveStatusUsageSummary;
+	const resolveGatewayHealthSummary = params.resolveHealth ?? resolveStatusGatewayHealth;
+	const usage = params.usage ? await resolveUsageSummary(params.timeoutMs) : void 0;
+	const health = params.deep ? params.suppressHealthErrors ? await resolveGatewayHealthSummary({
+		config: params.config,
+		timeoutMs: params.timeoutMs
+	}).catch(() => void 0) : await resolveGatewayHealthSummary({
+		config: params.config,
+		timeoutMs: params.timeoutMs
+	}) : void 0;
+	const lastHeartbeat = params.deep ? await resolveStatusLastHeartbeat({
+		config: params.config,
+		timeoutMs: params.timeoutMs,
+		gatewayReachable: params.gatewayReachable
+	}) : null;
+	const [gatewayService, nodeService] = await resolveStatusServiceSummaries();
+	return {
+		usage,
+		health,
+		lastHeartbeat,
+		gatewayService,
+		nodeService
+	};
+}
+async function resolveStatusRuntimeSnapshot(params) {
+	return {
+		securityAudit: params.includeSecurityAudit ? await (params.resolveSecurityAudit ?? resolveStatusSecurityAudit)({
+			config: params.config,
+			sourceConfig: params.sourceConfig
+		}) : void 0,
+		...await resolveStatusRuntimeDetails({
+			config: params.config,
+			timeoutMs: params.timeoutMs,
+			usage: params.usage,
+			deep: params.deep,
+			gatewayReachable: params.gatewayReachable,
+			suppressHealthErrors: params.suppressHealthErrors,
+			resolveUsage: params.resolveUsage,
+			resolveHealth: params.resolveHealth
+		})
+	};
+}
+//#endregion
+export { resolveStatusSecurityAudit as a, buildStatusGatewayJsonPayloadFromSurface as c, buildStatusOverviewSurfaceFromScan as d, resolveStatusRuntimeSnapshot as i, buildStatusOverviewRowsFromSurface as l, resolveStatusGatewayHealth as n, resolveStatusServiceSummaries as o, resolveStatusGatewayHealthSafe as r, resolveStatusUsageSummary as s, loadStatusProviderUsageModule as t, buildStatusOverviewSurfaceFromOverview as u };

package/dist/status-subagents.runtime-CuRGoNNn.js

@@ -0,0 +1,18 @@
+import { i as countPendingDescendantRuns } from "./subagent-registry-BgQA8eP1.js";
+import { o as resolveSubagentLabel } from "./subagents-format-C1DSWmGn.js";
+import { o as listControlledSubagentRuns } from "./subagent-control-Bn8n-535.js";
+//#region src/auto-reply/reply/commands-status-subagents.ts
+function buildSubagentsStatusLine(params) {
+	const { runs, verboseEnabled, pendingDescendantsForRun } = params;
+	if (runs.length === 0) return;
+	const active = runs.filter((entry) => !entry.endedAt || pendingDescendantsForRun(entry) > 0);
+	const done = runs.length - active.length;
+	if (verboseEnabled) {
+		const labels = active.map((entry) => resolveSubagentLabel(entry, "")).filter(Boolean).slice(0, 3);
+		const labelText = labels.length ? ` (${labels.join(", ")})` : "";
+		return `🤖 Subagents: ${active.length} active${labelText} · ${done} done`;
+	}
+	if (active.length > 0) return `🤖 Subagents: ${active.length} active`;
+}
+//#endregion
+export { buildSubagentsStatusLine, countPendingDescendantRuns, listControlledSubagentRuns };

package/dist/status-subagents.runtime.js

@@ -1 +1 @@
-export * from "./status-subagents.runtime-B4UXD0lL.js";
+export * from "./status-subagents.runtime-CuRGoNNn.js";