@pixelzx/genesis 2026.5.3-5 → 2026.5.5

package/dist/status-text-BrcRsCFE.js

@@ -0,0 +1,237 @@
+import { s as normalizeOptionalLowercaseString } from "./string-coerce-C1IzJjqi.js";
+import { r as toAgentModelListLike } from "./model-input-BkKFdMSQ.js";
+import { _ as resolveAgentConfig, p as resolveSessionAgentId, s as resolveAgentModelFallbacksOverride, x as resolveDefaultAgentId, y as resolveAgentDir } from "./agent-scope-CDjZLqNk.js";
+import { i as selectAgentHarness } from "./selection-hUGDnCgX.js";
+import { o as resolveInternalSessionKey, s as resolveMainSessionAlias } from "./sessions-helpers-YOu_5tl0.js";
+import { n as formatTaskStatusDetail, r as formatTaskStatusTitle, t as buildTaskStatusSnapshot } from "./task-status-LIWTrTqj.js";
+import { m as listTasksForSessionKey, u as listTasksForAgentId } from "./task-registry-B-kQGKt_.js";
+import { t as normalizeGroupActivation } from "./group-activation-C_gTAl_1.js";
+import { t as resolveFastModeState } from "./fast-mode-Cw7-WKiu.js";
+import { t as resolveModelAuthLabel } from "./model-auth-label-BAtXJxa0.js";
+import { o as resolveUsageProviderId } from "./provider-usage.shared-CcvPrv1N.js";
+import { n as resolveSelectedAndActiveModel } from "./model-runtime-CqCHE23D.js";
+import { r as formatUsageWindowSummary } from "./provider-usage-DtCUHOBT.js";
+import { t as loadProviderUsageSummary } from "./provider-usage.load-DfxOyIjr.js";
+//#region src/tasks/task-status-access.ts
+function listTasksForSessionKeyForStatus(sessionKey) {
+	return listTasksForSessionKey(sessionKey);
+}
+function listTasksForAgentIdForStatus(agentId) {
+	return listTasksForAgentId(agentId);
+}
+//#endregion
+//#region src/status/status-text.ts
+const USAGE_OAUTH_ONLY_PROVIDERS = new Set([
+	"anthropic",
+	"github-copilot",
+	"google-gemini-cli",
+	"openai-codex"
+]);
+let statusMessageRuntimePromise = null;
+let statusQueueRuntimePromise = null;
+let statusSubagentsRuntimePromise = null;
+function loadStatusMessageRuntime() {
+	return statusMessageRuntimePromise ??= import("./status-message.runtime-i6HSwq0C.js").then((module) => module.loadStatusMessageRuntimeModule());
+}
+function loadStatusSubagentsRuntime() {
+	return statusSubagentsRuntimePromise ??= import("./status-subagents.runtime-CuRGoNNn.js");
+}
+function loadStatusQueueRuntime() {
+	return statusQueueRuntimePromise ??= import("./status-queue.runtime-Dpqj1jlp.js");
+}
+function shouldLoadUsageSummary(params) {
+	if (!params.provider) return false;
+	if (!USAGE_OAUTH_ONLY_PROVIDERS.has(params.provider)) return true;
+	const auth = normalizeOptionalLowercaseString(params.selectedModelAuth);
+	return Boolean(auth?.startsWith("oauth") || auth?.startsWith("token"));
+}
+function formatSessionTaskLine(sessionKey) {
+	const snapshot = buildTaskStatusSnapshot(listTasksForSessionKeyForStatus(sessionKey));
+	const task = snapshot.focus;
+	if (!task) return;
+	const headline = snapshot.activeCount > 0 ? `${snapshot.activeCount} active · ${snapshot.totalCount} total` : snapshot.recentFailureCount > 0 ? `${snapshot.recentFailureCount} recent failure${snapshot.recentFailureCount === 1 ? "" : "s"}` : "recently finished";
+	const title = formatTaskStatusTitle(task);
+	const detail = formatTaskStatusDetail(task);
+	const parts = [
+		headline,
+		task.runtime,
+		title,
+		detail
+	].filter(Boolean);
+	return parts.length ? `📌 Tasks: ${parts.join(" · ")}` : void 0;
+}
+function resolveStatusHarnessId(params) {
+	try {
+		const id = normalizeOptionalLowercaseString(selectAgentHarness({
+			provider: params.provider,
+			modelId: params.model,
+			config: params.cfg,
+			agentId: params.agentId,
+			sessionKey: params.sessionKey,
+			agentHarnessId: params.sessionEntry?.agentHarnessId
+		}).id);
+		return id && id !== "pi" ? id : void 0;
+	} catch {
+		return;
+	}
+}
+function formatAgentTaskCountsLine(agentId) {
+	const snapshot = buildTaskStatusSnapshot(listTasksForAgentIdForStatus(agentId));
+	if (snapshot.totalCount === 0) return;
+	return `📌 Tasks: ${snapshot.activeCount} active · ${snapshot.totalCount} total · agent-local`;
+}
+async function buildStatusText(params) {
+	const { cfg, sessionEntry, sessionKey, parentSessionKey, sessionScope, storePath, statusChannel, provider, model, contextTokens, resolvedThinkLevel, resolvedFastMode, resolvedVerboseLevel, resolvedReasoningLevel, resolvedElevatedLevel, resolveDefaultThinkingLevel, isGroup, defaultGroupActivation } = params;
+	const statusAgentId = sessionKey ? resolveSessionAgentId({
+		sessionKey,
+		config: cfg
+	}) : resolveDefaultAgentId(cfg);
+	const statusAgentDir = resolveAgentDir(cfg, statusAgentId);
+	const modelRefs = resolveSelectedAndActiveModel({
+		selectedProvider: provider,
+		selectedModel: model,
+		sessionEntry
+	});
+	const selectedModelAuth = Object.hasOwn(params, "modelAuthOverride") ? params.modelAuthOverride : resolveModelAuthLabel({
+		provider,
+		cfg,
+		sessionEntry,
+		agentDir: statusAgentDir,
+		includeExternalProfiles: false
+	});
+	const activeModelAuth = Object.hasOwn(params, "activeModelAuthOverride") ? params.activeModelAuthOverride : modelRefs.activeDiffers ? resolveModelAuthLabel({
+		provider: modelRefs.active.provider,
+		cfg,
+		sessionEntry,
+		agentDir: statusAgentDir,
+		includeExternalProfiles: false
+	}) : selectedModelAuth;
+	const currentUsageProvider = (() => {
+		try {
+			return resolveUsageProviderId(provider);
+		} catch {
+			return;
+		}
+	})();
+	let usageLine = null;
+	if (currentUsageProvider && shouldLoadUsageSummary({
+		provider: currentUsageProvider,
+		selectedModelAuth
+	})) try {
+		const usageSummaryTimeoutMs = 3500;
+		let usageTimeout;
+		const usageEntry = (await Promise.race([loadProviderUsageSummary({
+			timeoutMs: usageSummaryTimeoutMs,
+			providers: [currentUsageProvider],
+			agentDir: statusAgentDir
+		}), new Promise((_, reject) => {
+			usageTimeout = setTimeout(() => reject(/* @__PURE__ */ new Error("usage summary timeout")), usageSummaryTimeoutMs);
+		})]).finally(() => {
+			if (usageTimeout) clearTimeout(usageTimeout);
+		})).providers[0];
+		if (usageEntry && !usageEntry.error && usageEntry.windows.length > 0) {
+			const summaryLine = formatUsageWindowSummary(usageEntry, {
+				now: Date.now(),
+				maxWindows: 2,
+				includeResets: true
+			});
+			if (summaryLine) usageLine = `📊 Usage: ${summaryLine}`;
+		}
+	} catch {
+		usageLine = null;
+	}
+	const { getFollowupQueueDepth, resolveQueueSettings } = await loadStatusQueueRuntime();
+	const queueSettings = resolveQueueSettings({
+		cfg,
+		channel: statusChannel,
+		sessionEntry
+	});
+	const queueKey = sessionKey ?? sessionEntry?.sessionId;
+	const queueDepth = queueKey ? getFollowupQueueDepth(queueKey) : 0;
+	const queueOverrides = Boolean(sessionEntry?.queueDebounceMs ?? sessionEntry?.queueCap ?? sessionEntry?.queueDrop);
+	let subagentsLine;
+	let taskLine;
+	if (sessionKey) {
+		const { mainKey, alias } = resolveMainSessionAlias(cfg);
+		const requesterKey = resolveInternalSessionKey({
+			key: sessionKey,
+			alias,
+			mainKey
+		});
+		taskLine = params.skipDefaultTaskLookup ? params.taskLineOverride : params.taskLineOverride ?? formatSessionTaskLine(requesterKey);
+		if (!taskLine && !params.skipDefaultTaskLookup) taskLine = formatAgentTaskCountsLine(statusAgentId);
+		const { buildSubagentsStatusLine, countPendingDescendantRuns, listControlledSubagentRuns } = await loadStatusSubagentsRuntime();
+		subagentsLine = buildSubagentsStatusLine({
+			runs: listControlledSubagentRuns(requesterKey),
+			verboseEnabled: resolvedVerboseLevel && resolvedVerboseLevel !== "off",
+			pendingDescendantsForRun: (entry) => countPendingDescendantRuns(entry.childSessionKey)
+		});
+	}
+	const groupActivation = isGroup ? normalizeGroupActivation(sessionEntry?.groupActivation) ?? defaultGroupActivation() : void 0;
+	const agentDefaults = cfg.agents?.defaults ?? {};
+	const agentConfig = resolveAgentConfig(cfg, statusAgentId);
+	const effectiveFastMode = resolvedFastMode ?? resolveFastModeState({
+		cfg,
+		provider,
+		model,
+		agentId: statusAgentId,
+		sessionEntry
+	}).enabled;
+	const effectiveHarness = params.resolvedHarness ?? resolveStatusHarnessId({
+		cfg,
+		provider,
+		model,
+		agentId: statusAgentId,
+		sessionKey,
+		sessionEntry
+	});
+	const agentFallbacksOverride = resolveAgentModelFallbacksOverride(cfg, statusAgentId);
+	const { buildStatusMessage } = await loadStatusMessageRuntime();
+	const explicitThinkingDefault = agentConfig?.thinkingDefault ?? agentDefaults.thinkingDefault;
+	return buildStatusMessage({
+		config: cfg,
+		agent: {
+			...agentDefaults,
+			model: {
+				...toAgentModelListLike(agentDefaults.model),
+				primary: params.primaryModelLabelOverride ?? `${provider}/${model}`,
+				...agentFallbacksOverride === void 0 ? {} : { fallbacks: agentFallbacksOverride }
+			},
+			...typeof contextTokens === "number" && contextTokens > 0 ? { contextTokens } : {},
+			thinkingDefault: explicitThinkingDefault,
+			verboseDefault: agentDefaults.verboseDefault,
+			elevatedDefault: agentDefaults.elevatedDefault
+		},
+		agentId: statusAgentId,
+		explicitConfiguredContextTokens: typeof agentDefaults.contextTokens === "number" && agentDefaults.contextTokens > 0 ? agentDefaults.contextTokens : void 0,
+		sessionEntry,
+		sessionKey,
+		parentSessionKey,
+		sessionScope,
+		sessionStorePath: storePath,
+		groupActivation,
+		resolvedThink: resolvedThinkLevel ?? explicitThinkingDefault ?? await resolveDefaultThinkingLevel(),
+		resolvedFast: effectiveFastMode,
+		resolvedHarness: effectiveHarness,
+		resolvedVerbose: resolvedVerboseLevel,
+		resolvedReasoning: resolvedReasoningLevel,
+		resolvedElevated: resolvedElevatedLevel,
+		modelAuth: selectedModelAuth,
+		activeModelAuth,
+		usageLine: usageLine ?? void 0,
+		queue: {
+			mode: queueSettings.mode,
+			depth: queueDepth,
+			debounceMs: queueSettings.debounceMs,
+			cap: queueSettings.cap,
+			dropPolicy: queueSettings.dropPolicy,
+			showDetails: queueOverrides
+		},
+		subagentsLine,
+		taskLine,
+		mediaDecisions: params.mediaDecisions,
+		includeTranscriptUsage: params.includeTranscriptUsage ?? true
+	});
+}
+//#endregion
+export { listTasksForAgentIdForStatus as n, listTasksForSessionKeyForStatus as r, buildStatusText as t };

package/dist/status-zV1BflCE.js

@@ -0,0 +1,3 @@
+import { t as statusCommand } from "./status-C6qTe-QQ.js";
+import "./status.summary-Bvgry977.js";
+export { statusCommand };

package/dist/status.gateway-connection.runtime-BKd4Zivg.js

@@ -0,0 +1,2 @@
+import { n as buildGatewayConnectionDetails } from "./call-DkGNVvLy.js";
+export { buildGatewayConnectionDetails };

package/dist/status.gateway-connection.runtime.js

@@ -1 +1 @@
-export * from "./status.gateway-connection.runtime-B0Iwl2iZ.js";
+export * from "./status.gateway-connection.runtime-BKd4Zivg.js";

package/dist/status.gather-B7WlHpIR.js

@@ -0,0 +1,292 @@
+import { n as resolvePreferredGenesisTmpDir, t as POSIX_GENESIS_TMP_DIR } from "./tmp-genesis-dir-B4F3mzr8.js";
+import { _ as resolveStateDir, o as resolveConfigPath, u as resolveGatewayPort } from "./paths-DmR9mjUX.js";
+import { a as trimToUndefined } from "./credential-planner-Bf6MFQ6Y.js";
+import "./credentials-C7JHJpIV.js";
+import { r as createConfigIO } from "./io-h8M_Z0Lj.js";
+import { i as parseStrictPositiveInteger } from "./parse-finite-number-De8ORAh1.js";
+import { a as inspectPortUsage, s as formatPortDiagnostics } from "./ports-BRobddkK.js";
+import { r as resolveGatewayService } from "./service-ChLFBF7Q.js";
+import { c as pickProbeHostForBind, o as normalizeListenerAddress, s as parsePortFromArgs } from "./shared-BdZN5DvO.js";
+import "./config-B3ZoZd5V.js";
+import { t as readLastGatewayErrorLine } from "./diagnostics-CaaOG0Lm.js";
+import { r as resolveBestEffortGatewayBindHostForDisplay, t as inspectBestEffortPrimaryTailnetIPv4 } from "./network-discovery-display-Dc1wyEHW.js";
+import path from "node:path";
+//#region src/logging/log-file-path.ts
+const LOG_PREFIX = "genesis";
+const LOG_SUFFIX = ".log";
+function canUseNodeFs() {
+	const getBuiltinModule = process.getBuiltinModule;
+	if (typeof getBuiltinModule !== "function") return false;
+	try {
+		return getBuiltinModule("fs") !== void 0;
+	} catch {
+		return false;
+	}
+}
+function formatLocalDate(date) {
+	return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")}`;
+}
+function resolveDefaultRollingLogFile(date = /* @__PURE__ */ new Date()) {
+	const logDir = canUseNodeFs() ? resolvePreferredGenesisTmpDir() : POSIX_GENESIS_TMP_DIR;
+	return path.join(logDir, `${LOG_PREFIX}-${formatLocalDate(date)}${LOG_SUFFIX}`);
+}
+function resolveConfiguredLogFilePath(config) {
+	return config?.logging?.file ?? resolveDefaultRollingLogFile();
+}
+//#endregion
+//#region src/cli/daemon-cli/status.gather.ts
+let gatewayProbeAuthModulePromise;
+let daemonInspectModulePromise;
+let serviceAuditModulePromise;
+let gatewayTlsModulePromise;
+let daemonProbeModulePromise;
+let restartHealthModulePromise;
+function loadGatewayProbeAuthModule() {
+	gatewayProbeAuthModulePromise ??= import("./probe-auth-Cj-QBrHA.js");
+	return gatewayProbeAuthModulePromise;
+}
+function loadDaemonInspectModule() {
+	daemonInspectModulePromise ??= import("./inspect-BgP5GHO8.js");
+	return daemonInspectModulePromise;
+}
+function loadServiceAuditModule() {
+	serviceAuditModulePromise ??= import("./service-audit-cqHyD5gB.js");
+	return serviceAuditModulePromise;
+}
+function loadGatewayTlsModule() {
+	gatewayTlsModulePromise ??= import("./gateway-17zG645d.js");
+	return gatewayTlsModulePromise;
+}
+function loadDaemonProbeModule() {
+	daemonProbeModulePromise ??= import("./probe-DIMAmSsO.js");
+	return daemonProbeModulePromise;
+}
+function loadRestartHealthModule() {
+	restartHealthModulePromise ??= import("./restart-health-b6Qw43Tj.js");
+	return restartHealthModulePromise;
+}
+function resolveSnapshotRuntimeConfig(snapshot) {
+	if (!snapshot?.valid || !snapshot.runtimeConfig) return null;
+	return snapshot.runtimeConfig;
+}
+function appendProbeNote(existing, extra) {
+	const values = [existing, extra].filter((value) => Boolean(value?.trim()));
+	if (values.length === 0) return;
+	return [...new Set(values)].join(" ");
+}
+function shouldReportPortUsage(status, rpcOk) {
+	if (status !== "busy") return false;
+	if (rpcOk === true) return false;
+	return true;
+}
+async function loadDaemonConfigContext(serviceEnv) {
+	const mergedDaemonEnv = {
+		...process.env,
+		...serviceEnv ?? void 0
+	};
+	const cliConfigPath = resolveConfigPath(process.env, resolveStateDir(process.env));
+	const daemonConfigPath = resolveConfigPath(mergedDaemonEnv, resolveStateDir(mergedDaemonEnv));
+	const cliIO = createConfigIO({
+		env: process.env,
+		configPath: cliConfigPath,
+		pluginValidation: "skip"
+	});
+	const sharesDaemonConfigContext = !serviceEnv && cliConfigPath === daemonConfigPath;
+	const daemonIO = sharesDaemonConfigContext ? cliIO : createConfigIO({
+		env: mergedDaemonEnv,
+		configPath: daemonConfigPath,
+		pluginValidation: "skip"
+	});
+	const cliSnapshotPromise = cliIO.readConfigFileSnapshot().catch(() => null);
+	const daemonSnapshotPromise = sharesDaemonConfigContext ? cliSnapshotPromise : daemonIO.readConfigFileSnapshot().catch(() => null);
+	const [cliSnapshot, daemonSnapshot] = await Promise.all([cliSnapshotPromise, daemonSnapshotPromise]);
+	const cliCfg = resolveSnapshotRuntimeConfig(cliSnapshot) ?? cliIO.loadConfig();
+	const daemonCfg = sharesDaemonConfigContext && cliSnapshot === daemonSnapshot ? cliCfg : resolveSnapshotRuntimeConfig(daemonSnapshot) ?? daemonIO.loadConfig();
+	const cliConfigSummary = {
+		path: cliSnapshot?.path ?? cliConfigPath,
+		exists: cliSnapshot?.exists ?? false,
+		valid: cliSnapshot?.valid ?? true,
+		...cliSnapshot?.issues?.length ? { issues: cliSnapshot.issues } : {},
+		controlUi: cliCfg.gateway?.controlUi
+	};
+	const daemonConfigSummary = {
+		path: daemonSnapshot?.path ?? daemonConfigPath,
+		exists: daemonSnapshot?.exists ?? false,
+		valid: daemonSnapshot?.valid ?? true,
+		...daemonSnapshot?.issues?.length ? { issues: daemonSnapshot.issues } : {},
+		controlUi: daemonCfg.gateway?.controlUi
+	};
+	return {
+		mergedDaemonEnv,
+		cliCfg,
+		daemonCfg,
+		cliConfigSummary,
+		daemonConfigSummary,
+		configMismatch: cliConfigSummary.path !== daemonConfigSummary.path
+	};
+}
+async function resolveGatewayStatusSummary(params) {
+	const portFromArgs = parsePortFromArgs(params.commandProgramArguments);
+	const daemonPort = portFromArgs ?? resolveGatewayPort(params.daemonCfg, params.mergedDaemonEnv);
+	const portSource = portFromArgs ? "service args" : "env/config";
+	const bindMode = params.daemonCfg.gateway?.bind ?? "loopback";
+	const customBindHost = params.daemonCfg.gateway?.customBindHost;
+	const { bindHost, warning: bindHostWarning } = await resolveBestEffortGatewayBindHostForDisplay({
+		bindMode,
+		customBindHost,
+		warningPrefix: "Status is using fallback network details because interface discovery failed"
+	});
+	const { tailnetIPv4, warning: tailnetWarning } = inspectBestEffortPrimaryTailnetIPv4({ warningPrefix: "Status could not inspect tailnet addresses" });
+	const probeHost = pickProbeHostForBind(bindMode, tailnetIPv4, customBindHost);
+	const probeUrlOverride = trimToUndefined(params.rpcUrlOverride) ?? null;
+	const scheme = params.daemonCfg.gateway?.tls?.enabled === true ? "wss" : "ws";
+	const probeUrl = probeUrlOverride ?? `${scheme}://${probeHost}:${daemonPort}`;
+	let probeNote = !probeUrlOverride && bindMode === "lan" ? `bind=lan listens on 0.0.0.0 (all interfaces); probing via ${probeHost}.` : !probeUrlOverride && bindMode === "loopback" ? "Loopback-only gateway; only local clients can connect." : void 0;
+	probeNote = appendProbeNote(probeNote, bindHostWarning);
+	probeNote = appendProbeNote(probeNote, tailnetWarning);
+	return {
+		gateway: {
+			bindMode,
+			bindHost,
+			customBindHost,
+			port: daemonPort,
+			portSource,
+			probeUrl,
+			...probeNote ? { probeNote } : {}
+		},
+		daemonPort,
+		cliPort: resolveGatewayPort(params.cliCfg, process.env),
+		probeUrlOverride
+	};
+}
+function toPortStatusSummary(diagnostics) {
+	if (!diagnostics) return;
+	return {
+		port: diagnostics.port,
+		status: diagnostics.status,
+		listeners: diagnostics.listeners,
+		hints: diagnostics.hints
+	};
+}
+async function inspectDaemonPortStatuses(params) {
+	const [portDiagnostics, portCliDiagnostics] = await Promise.all([inspectPortUsage(params.daemonPort).catch(() => null), params.cliPort !== params.daemonPort ? inspectPortUsage(params.cliPort).catch(() => null) : null]);
+	return {
+		portStatus: toPortStatusSummary(portDiagnostics),
+		portCliStatus: toPortStatusSummary(portCliDiagnostics)
+	};
+}
+async function gatherDaemonStatus(opts) {
+	const service = resolveGatewayService();
+	const command = await service.readCommand(process.env).catch(() => null);
+	const serviceEnv = command?.environment ? {
+		...process.env,
+		...command.environment
+	} : process.env;
+	const [loaded, runtime] = await Promise.all([service.isLoaded({ env: serviceEnv }).catch(() => false), service.readRuntime(serviceEnv).catch((err) => ({
+		status: "unknown",
+		detail: String(err)
+	}))]);
+	const configAudit = command ? await loadServiceAuditModule().then(({ auditGatewayServiceConfig }) => auditGatewayServiceConfig({
+		env: process.env,
+		command
+	})) : {
+		ok: true,
+		issues: []
+	};
+	const { mergedDaemonEnv, cliCfg, daemonCfg, cliConfigSummary, daemonConfigSummary, configMismatch } = await loadDaemonConfigContext(command?.environment);
+	const { gateway, daemonPort, cliPort, probeUrlOverride } = await resolveGatewayStatusSummary({
+		cliCfg,
+		daemonCfg,
+		mergedDaemonEnv,
+		commandProgramArguments: command?.programArguments,
+		rpcUrlOverride: opts.rpc.url
+	});
+	const { portStatus, portCliStatus } = await inspectDaemonPortStatuses({
+		daemonPort,
+		cliPort
+	});
+	const extraServices = opts.deep ? await loadDaemonInspectModule().then(({ findExtraGatewayServices }) => findExtraGatewayServices(process.env, { deep: true })).catch(() => []) : [];
+	const timeoutMs = parseStrictPositiveInteger(opts.rpc.timeout ?? "10000") ?? 1e4;
+	const tlsEnabled = daemonCfg.gateway?.tls?.enabled === true;
+	const shouldUseLocalTlsRuntime = opts.probe && !probeUrlOverride && tlsEnabled;
+	const tlsRuntime = shouldUseLocalTlsRuntime ? await loadGatewayTlsModule().then(({ loadGatewayTlsRuntime }) => loadGatewayTlsRuntime(daemonCfg.gateway?.tls)) : void 0;
+	let daemonProbeAuth;
+	let rpcAuthWarning;
+	if (opts.probe) {
+		const probeMode = daemonCfg.gateway?.mode === "remote" ? "remote" : "local";
+		const probeAuthResolution = await loadGatewayProbeAuthModule().then(({ resolveGatewayProbeAuthSafeWithSecretInputs }) => resolveGatewayProbeAuthSafeWithSecretInputs({
+			cfg: daemonCfg,
+			mode: probeMode,
+			env: mergedDaemonEnv,
+			explicitAuth: {
+				token: opts.rpc.token,
+				password: opts.rpc.password
+			}
+		}));
+		daemonProbeAuth = probeAuthResolution.auth;
+		rpcAuthWarning = probeAuthResolution.warning;
+	}
+	const rpc = opts.probe ? await loadDaemonProbeModule().then(({ probeGatewayStatus }) => probeGatewayStatus({
+		url: gateway.probeUrl,
+		token: daemonProbeAuth?.token,
+		password: daemonProbeAuth?.password,
+		tlsFingerprint: shouldUseLocalTlsRuntime && tlsRuntime?.enabled ? tlsRuntime.fingerprintSha256 : void 0,
+		timeoutMs,
+		json: opts.rpc.json,
+		requireRpc: opts.requireRpc,
+		configPath: daemonConfigSummary.path
+	})) : void 0;
+	if (rpc?.ok) rpcAuthWarning = void 0;
+	const health = opts.probe && loaded && rpc?.ok !== true ? await loadRestartHealthModule().then(({ inspectGatewayRestart }) => inspectGatewayRestart({
+		service,
+		port: daemonPort,
+		env: serviceEnv
+	})).catch(() => void 0) : void 0;
+	let lastError;
+	if (loaded && runtime?.status === "running" && portStatus && portStatus.status !== "busy") lastError = await readLastGatewayErrorLine(mergedDaemonEnv) ?? void 0;
+	return {
+		logFile: resolveConfiguredLogFilePath(cliCfg),
+		service: {
+			label: service.label,
+			loaded,
+			loadedText: service.loadedText,
+			notLoadedText: service.notLoadedText,
+			command,
+			runtime,
+			configAudit
+		},
+		config: {
+			cli: cliConfigSummary,
+			daemon: daemonConfigSummary,
+			...configMismatch ? { mismatch: true } : {}
+		},
+		gateway,
+		port: portStatus,
+		...portCliStatus ? { portCli: portCliStatus } : {},
+		lastError,
+		...rpc ? { rpc: {
+			...rpc,
+			url: gateway.probeUrl,
+			...rpcAuthWarning ? { authWarning: rpcAuthWarning } : {}
+		} } : {},
+		...health ? { health: {
+			healthy: health.healthy,
+			staleGatewayPids: health.staleGatewayPids
+		} } : {},
+		extraServices
+	};
+}
+function renderPortDiagnosticsForCli(status, rpcOk) {
+	if (!status.port || !shouldReportPortUsage(status.port.status, rpcOk)) return [];
+	return formatPortDiagnostics({
+		port: status.port.port,
+		status: status.port.status,
+		listeners: status.port.listeners,
+		hints: status.port.hints
+	});
+}
+function resolvePortListeningAddresses(status) {
+	return Array.from(new Set(status.port?.listeners?.map((l) => l.address ? normalizeListenerAddress(l.address) : "").filter((v) => Boolean(v)) ?? []));
+}
+//#endregion
+export { renderPortDiagnosticsForCli as n, resolvePortListeningAddresses as r, gatherDaemonStatus as t };

package/dist/status.gather-Ccewg4ce.js

@@ -0,0 +1,2 @@
+import { n as renderPortDiagnosticsForCli, r as resolvePortListeningAddresses, t as gatherDaemonStatus } from "./status.gather-B7WlHpIR.js";
+export { gatherDaemonStatus, renderPortDiagnosticsForCli, resolvePortListeningAddresses };

package/dist/status.runtime-BFru2C4v.js

@@ -0,0 +1,2 @@
+import { t as runDaemonStatus } from "./status-p4yx6E3C.js";
+export { runDaemonStatus };

package/dist/status.runtime.js

@@ -1 +1 @@
-export * from "./status.runtime-Cxyb3wHZ.js";
+export * from "./status.runtime-BFru2C4v.js";

package/dist/status.scan-mEKnAmP3.js

@@ -0,0 +1,65 @@
+import { i as hasConfiguredChannelsForReadOnlyScope } from "./channel-plugin-ids-U_QWzG9d.js";
+import { n as withProgress } from "./progress-C6QDkZMg.js";
+import { r as buildPluginCompatibilitySnapshotNotices } from "./status-DuZdkulz.js";
+import { t as collectStatusScanOverview } from "./status.scan-overview-B0qQVJd0.js";
+import { i as executeStatusScanFromOverview, n as scanStatusJsonWithPolicy, r as resolveStatusMemoryStatusSnapshot } from "./status.scan.fast-json-CsU-fWhj.js";
+//#region src/commands/status.scan.ts
+async function scanStatus(opts, _runtime) {
+	if (opts.json) return await scanStatusJsonWithPolicy({
+		timeoutMs: opts.timeoutMs,
+		all: opts.all
+	}, _runtime, {
+		commandName: "status --json",
+		resolveHasConfiguredChannels: (cfg, sourceConfig) => hasConfiguredChannelsForReadOnlyScope({
+			config: cfg,
+			activationSourceConfig: sourceConfig
+		}),
+		resolveMemory: async ({ cfg, agentStatus, memoryPlugin }) => await resolveStatusMemoryStatusSnapshot({
+			cfg,
+			agentStatus,
+			memoryPlugin
+		})
+	});
+	return await withProgress({
+		label: "Scanning status…",
+		total: 10,
+		enabled: true
+	}, async (progress) => {
+		const overview = await collectStatusScanOverview({
+			commandName: "status",
+			opts,
+			showSecrets: process.env.GENESIS_SHOW_SECRETS?.trim() !== "0",
+			progress,
+			labels: {
+				loadingConfig: "Loading config…",
+				checkingTailscale: "Checking Tailscale…",
+				checkingForUpdates: "Checking for updates…",
+				resolvingAgents: "Resolving agents…",
+				probingGateway: "Probing gateway…",
+				queryingChannelStatus: "Querying channel status…",
+				summarizingChannels: "Summarizing channels…"
+			}
+		});
+		progress.setLabel("Checking plugins…");
+		const pluginCompatibility = buildPluginCompatibilitySnapshotNotices({ config: overview.cfg });
+		progress.tick();
+		progress.setLabel("Checking memory and sessions…");
+		const result = await executeStatusScanFromOverview({
+			overview,
+			resolveMemory: async ({ cfg, agentStatus, memoryPlugin }) => await resolveStatusMemoryStatusSnapshot({
+				cfg,
+				agentStatus,
+				memoryPlugin
+			}),
+			channelIssues: overview.channelIssues,
+			channels: overview.channels,
+			pluginCompatibility
+		});
+		progress.tick();
+		progress.setLabel("Rendering…");
+		progress.tick();
+		return result;
+	});
+}
+//#endregion
+export { scanStatus };