@pixelzx/genesis 2026.7.8 → 2026.7.9

package/dist/status-CJA5y0Ot.js

@@ -0,0 +1,190 @@
+import { i as formatErrorMessage } from "./errors-CufR9eHH.js";
+import { n as defaultRuntime, r as writeRuntimeJson } from "./runtime-DDkDH9fa.js";
+import { t as formatDocsLink } from "./links-C1-jbHJx.js";
+import { r as theme } from "./theme-DD6pQv2_.js";
+import { t as formatCliCommand } from "./command-format-B3Q5KD9o.js";
+import { u as readConfigFileSnapshot } from "./io-Cy5vajWd.js";
+import "./config-DYHZ3jG1.js";
+import { o as redactSensitiveUrlLikeString } from "./redact-sensitive-url-CFMv91U5.js";
+import { r as callGateway } from "./call-CoL9QpLf.js";
+import { s as listConfiguredChannelIdsForReadOnlyScope } from "./channel-plugin-ids-CJMxicW6.js";
+import { t as listReadOnlyChannelPluginsForConfig } from "./read-only-B2cFHgh2.js";
+import { r as getConfiguredChannelsCommandSecretTargetIds } from "./command-secret-targets-DRpr1JEj.js";
+import { n as formatTimeAgo } from "./format-relative-B39tx_LC.js";
+import { n as withProgress } from "./progress-DwK5aAgj.js";
+import { n as hasResolvedCredentialValue, t as hasConfiguredUnavailableCredentialStatus } from "./account-snapshot-fields-7tcmFFXl.js";
+import { t as resolveCommandConfigWithSecrets } from "./command-config-resolution-D_HiK2Df.js";
+import { n as requireValidConfigSnapshot } from "./config-validation-JqbUug0f.js";
+import { a as buildChannelAccountLine, i as appendTokenSourceBits, n as appendEnabledConfiguredLinkedBits, r as appendModeBit, t as appendBaseUrlBit } from "./shared-C9DEgBKO.js";
+import { n as buildReadOnlySourceChannelAccountSnapshot, t as buildChannelAccountSnapshot } from "./status-eYkbBTxW.js";
+import { t as collectChannelStatusIssues } from "./channels-status-issues-4qduZzFD.js";
+//#region src/commands/channels/status-config-format.ts
+async function formatConfigChannelsStatusLines(cfg, meta, opts) {
+	const lines = [];
+	lines.push(theme.warn("Gateway not reachable; showing config-only status."));
+	if (meta.path) lines.push(`Config: ${meta.path}`);
+	if (meta.mode) lines.push(`Mode: ${meta.mode}`);
+	if (meta.path || meta.mode) lines.push("");
+	const accountLines = (provider, accounts) => accounts.map((account) => {
+		const bits = [];
+		appendEnabledConfiguredLinkedBits(bits, account);
+		appendModeBit(bits, account);
+		appendTokenSourceBits(bits, account);
+		appendBaseUrlBit(bits, account);
+		return buildChannelAccountLine(provider, account, bits);
+	});
+	const sourceConfig = opts?.sourceConfig ?? cfg;
+	const plugins = listReadOnlyChannelPluginsForConfig(cfg, { activationSourceConfig: sourceConfig });
+	for (const plugin of plugins) {
+		const accountIds = plugin.config.listAccountIds(cfg);
+		if (!accountIds.length) continue;
+		const snapshots = [];
+		for (const accountId of accountIds) {
+			const sourceSnapshot = await buildReadOnlySourceChannelAccountSnapshot({
+				plugin,
+				cfg: sourceConfig,
+				accountId
+			});
+			const resolvedSnapshot = await buildChannelAccountSnapshot({
+				plugin,
+				cfg,
+				accountId
+			});
+			snapshots.push(sourceSnapshot && hasConfiguredUnavailableCredentialStatus(sourceSnapshot) && (!hasResolvedCredentialValue(resolvedSnapshot) || sourceSnapshot.configured === true && resolvedSnapshot.configured === false) ? sourceSnapshot : resolvedSnapshot);
+		}
+		if (snapshots.length > 0) lines.push(...accountLines(plugin.id, snapshots));
+	}
+	lines.push("");
+	lines.push(`Tip: ${formatDocsLink("/cli#status", "status --deep")} adds gateway health probes to status output (requires a reachable gateway).`);
+	return lines;
+}
+//#endregion
+//#region src/commands/channels/status.ts
+function redactGatewayUrlSecretsInText(text) {
+	return text.replace(/\b(?:wss?|https?):\/\/[^\s"'<>]+/gi, (rawUrl) => {
+		return redactSensitiveUrlLikeString(rawUrl);
+	});
+}
+function formatChannelsStatusError(err) {
+	return redactGatewayUrlSecretsInText(formatErrorMessage(err));
+}
+function formatGatewayChannelsStatusLines(payload) {
+	const lines = [];
+	lines.push(theme.success("Gateway reachable."));
+	const accountLines = (provider, accounts) => accounts.map((account) => {
+		const bits = [];
+		appendEnabledConfiguredLinkedBits(bits, account);
+		if (typeof account.running === "boolean") bits.push(account.running ? "running" : "stopped");
+		if (typeof account.connected === "boolean") bits.push(account.connected ? "connected" : "disconnected");
+		const inboundAt = typeof account.lastInboundAt === "number" && Number.isFinite(account.lastInboundAt) ? account.lastInboundAt : null;
+		const outboundAt = typeof account.lastOutboundAt === "number" && Number.isFinite(account.lastOutboundAt) ? account.lastOutboundAt : null;
+		if (inboundAt) bits.push(`in:${formatTimeAgo(Date.now() - inboundAt)}`);
+		if (outboundAt) bits.push(`out:${formatTimeAgo(Date.now() - outboundAt)}`);
+		appendModeBit(bits, account);
+		const botUsername = (() => {
+			const bot = account.bot;
+			const probeBot = account.probe?.bot;
+			const raw = bot?.username ?? probeBot?.username ?? "";
+			if (typeof raw !== "string") return "";
+			const trimmed = raw.trim();
+			if (!trimmed) return "";
+			return trimmed.startsWith("@") ? trimmed : `@${trimmed}`;
+		})();
+		if (botUsername) bits.push(`bot:${botUsername}`);
+		if (typeof account.dmPolicy === "string" && account.dmPolicy.length > 0) bits.push(`dm:${account.dmPolicy}`);
+		if (Array.isArray(account.allowFrom) && account.allowFrom.length > 0) bits.push(`allow:${account.allowFrom.slice(0, 2).join(",")}`);
+		appendTokenSourceBits(bits, account);
+		const messageContent = account.application?.intents?.messageContent;
+		if (typeof messageContent === "string" && messageContent.length > 0 && messageContent !== "enabled") bits.push(`intents:content=${messageContent}`);
+		if (account.allowUnmentionedGroups === true) bits.push("groups:unmentioned");
+		appendBaseUrlBit(bits, account);
+		const probe = account.probe;
+		if (probe && typeof probe.ok === "boolean") bits.push(probe.ok ? "works" : "probe failed");
+		const audit = account.audit;
+		if (audit && typeof audit.ok === "boolean") bits.push(audit.ok ? "audit ok" : "audit failed");
+		if (typeof account.lastError === "string" && account.lastError) bits.push(`error:${account.lastError}`);
+		return buildChannelAccountLine(provider, account, bits);
+	});
+	const accountsByChannel = payload.channelAccounts;
+	const accountPayloads = {};
+	for (const channelId of Object.keys(accountsByChannel ?? {}).toSorted()) {
+		const raw = accountsByChannel?.[channelId];
+		if (Array.isArray(raw)) accountPayloads[channelId] = raw;
+	}
+	for (const channelId of Object.keys(accountPayloads).toSorted()) {
+		const accounts = accountPayloads[channelId];
+		if (accounts && accounts.length > 0) lines.push(...accountLines(channelId, accounts));
+	}
+	lines.push("");
+	const issues = collectChannelStatusIssues(payload);
+	if (issues.length > 0) {
+		lines.push(theme.warn("Warnings:"));
+		for (const issue of issues) lines.push(`- ${issue.channel} ${issue.accountId}: ${issue.message}${issue.fix ? ` (${issue.fix})` : ""}`);
+		lines.push(`- Run: ${formatCliCommand("genesis doctor")}`);
+		lines.push("");
+	}
+	lines.push(`Tip: ${formatDocsLink("/cli#status", "status --deep")} adds gateway health probes to status output (requires a reachable gateway).`);
+	return lines;
+}
+async function channelsStatusCommand(opts, runtime = defaultRuntime) {
+	const timeoutMs = Number(opts.timeout ?? (opts.probe ? 3e4 : 1e4));
+	const statusLabel = opts.probe ? "Checking channel status (probe)…" : "Checking channel status…";
+	if (opts.json !== true && !process.stderr.isTTY) runtime.log(statusLabel);
+	try {
+		const payload = await withProgress({
+			label: statusLabel,
+			indeterminate: true,
+			enabled: opts.json !== true
+		}, async () => await callGateway({
+			method: "channels.status",
+			params: {
+				probe: Boolean(opts.probe),
+				timeoutMs
+			},
+			timeoutMs
+		}));
+		if (opts.json) {
+			writeRuntimeJson(runtime, payload);
+			return;
+		}
+		runtime.log(formatGatewayChannelsStatusLines(payload).join("\n"));
+	} catch (err) {
+		const safeError = formatChannelsStatusError(err);
+		runtime.error(`Gateway not reachable: ${safeError}`);
+		const cfg = await requireValidConfigSnapshot(runtime);
+		if (!cfg) return;
+		const { resolvedConfig } = await resolveCommandConfigWithSecrets({
+			config: cfg,
+			commandName: "channels status",
+			targetIds: getConfiguredChannelsCommandSecretTargetIds(cfg),
+			mode: "read_only_status",
+			runtime
+		});
+		const snapshot = await readConfigFileSnapshot();
+		const mode = cfg.gateway?.mode === "remote" ? "remote" : "local";
+		if (opts.json) {
+			writeRuntimeJson(runtime, {
+				gatewayReachable: false,
+				error: safeError,
+				configOnly: true,
+				config: {
+					path: snapshot.path,
+					mode
+				},
+				configuredChannels: listConfiguredChannelIdsForReadOnlyScope({
+					config: resolvedConfig,
+					activationSourceConfig: cfg,
+					env: process.env,
+					includePersistedAuthState: false
+				})
+			});
+			return;
+		}
+		runtime.log((await formatConfigChannelsStatusLines(resolvedConfig, {
+			path: snapshot.path,
+			mode
+		}, { sourceConfig: cfg })).join("\n"));
+	}
+}
+//#endregion
+export { formatGatewayChannelsStatusLines as n, formatConfigChannelsStatusLines as r, channelsStatusCommand as t };

package/dist/status-JI5DGJgd.js

@@ -0,0 +1,395 @@
+import { t as sanitizeTerminalText } from "./safe-text-BV3CaaRc.js";
+import { c as normalizePairingConnectRequestId, d as readConnectPairingRequiredMessage, f as readPairingConnectErrorDetails } from "./connect-error-details-D_gb1kVo.js";
+import { n as withProgress } from "./progress-DwK5aAgj.js";
+import { t as logGatewayConnectionDetails } from "./status.gateway-connection-BhOd5mCy.js";
+import { a as resolveStatusSecurityAudit, d as buildStatusOverviewSurfaceFromScan, i as resolveStatusRuntimeSnapshot, n as resolveStatusGatewayHealth, s as resolveStatusUsageSummary, t as loadStatusProviderUsageModule } from "./status-runtime-shared-BHVKTX8F.js";
+import { t as runStatusJsonCommand } from "./status-json-command-D3gfSQpJ.js";
+import { n as statusChannelsTableColumns, t as buildStatusChannelsTableRows } from "./channels-table-BlBKk_y2.js";
+import { S as statusHealthColumns, _ as buildStatusPluginCompatibilityLines, b as buildStatusSystemEventsRows, c as buildStatusOverviewSection, d as buildStatusUsageSection, g as buildStatusPairingRecoveryLines, h as buildStatusHealthRows, l as buildStatusSessionsSection, m as buildStatusFooterLines, o as buildStatusChannelsTableSection, p as buildStatusCommandOverviewRows, s as buildStatusHealthSection, t as appendStatusReportSections, u as buildStatusSystemEventsSection, v as buildStatusSecurityAuditLines, x as buildStatusSystemEventsTrailer, y as buildStatusSessionsRows } from "./text-report-C5TiNkIC.js";
+import "./status.summary-BzdECSg9.js";
+//#region src/commands/status.command-report-data.ts
+async function buildStatusCommandReportData(params) {
+	const overviewRows = buildStatusCommandOverviewRows({
+		opts: params.opts,
+		surface: params.surface,
+		osLabel: params.osSummary.label,
+		summary: params.summary,
+		health: params.health,
+		agentStatus: params.agentStatus,
+		memory: params.memory,
+		memoryPlugin: params.memoryPlugin,
+		pluginCompatibility: params.pluginCompatibility,
+		ok: params.ok,
+		warn: params.warn,
+		muted: params.muted,
+		formatTimeAgo: params.formatTimeAgo,
+		formatKTokens: params.formatKTokens,
+		resolveMemoryVectorState: params.resolveMemoryVectorState,
+		resolveMemoryFtsState: params.resolveMemoryFtsState,
+		resolveMemoryCacheSummary: params.resolveMemoryCacheSummary,
+		updateValue: params.updateValue
+	});
+	const sessionsColumns = [
+		{
+			key: "Key",
+			header: "Key",
+			minWidth: 20,
+			flex: true
+		},
+		{
+			key: "Kind",
+			header: "Kind",
+			minWidth: 6
+		},
+		{
+			key: "Age",
+			header: "Age",
+			minWidth: 9
+		},
+		{
+			key: "Model",
+			header: "Model",
+			minWidth: 14
+		},
+		{
+			key: "Tokens",
+			header: "Tokens",
+			minWidth: 16
+		},
+		...params.opts.verbose ? [{
+			key: "Cache",
+			header: "Cache",
+			minWidth: 16,
+			flex: true
+		}] : []
+	];
+	const securityAudit = params.securityAudit ?? {
+		summary: {
+			critical: 0,
+			warn: 0,
+			info: 0
+		},
+		findings: []
+	};
+	return {
+		heading: params.theme.heading,
+		muted: params.theme.muted,
+		renderTable: params.renderTable,
+		width: params.tableWidth,
+		overviewRows,
+		showTaskMaintenanceHint: params.summary.taskAudit.errors > 0,
+		taskMaintenanceHint: `Task maintenance: ${params.formatCliCommand("genesis tasks maintenance --apply")}`,
+		pluginCompatibilityLines: buildStatusPluginCompatibilityLines({
+			notices: params.pluginCompatibility,
+			formatNotice: params.formatPluginCompatibilityNotice,
+			warn: params.theme.warn,
+			muted: params.theme.muted
+		}),
+		pairingRecoveryLines: buildStatusPairingRecoveryLines({
+			pairingRecovery: params.pairingRecovery,
+			warn: params.theme.warn,
+			muted: params.theme.muted,
+			formatCliCommand: params.formatCliCommand
+		}),
+		securityAuditLines: buildStatusSecurityAuditLines({
+			securityAudit,
+			theme: params.theme,
+			shortenText: params.shortenText,
+			formatCliCommand: params.formatCliCommand
+		}),
+		channelsColumns: statusChannelsTableColumns,
+		channelsRows: buildStatusChannelsTableRows({
+			rows: params.channels.rows,
+			channelIssues: params.channelIssues,
+			ok: params.ok,
+			warn: params.warn,
+			muted: params.muted,
+			accentDim: params.accentDim,
+			formatIssueMessage: (message) => params.shortenText(message, 84)
+		}),
+		sessionsColumns,
+		sessionsRows: buildStatusSessionsRows({
+			recent: params.summary.sessions.recent,
+			verbose: params.opts.verbose,
+			shortenText: params.shortenText,
+			formatTimeAgo: params.formatTimeAgo,
+			formatTokensCompact: params.formatTokensCompact,
+			formatPromptCacheCompact: params.formatPromptCacheCompact,
+			muted: params.muted
+		}),
+		systemEventsRows: buildStatusSystemEventsRows({ queuedSystemEvents: params.summary.queuedSystemEvents }),
+		systemEventsTrailer: buildStatusSystemEventsTrailer({
+			queuedSystemEvents: params.summary.queuedSystemEvents,
+			muted: params.muted
+		}),
+		healthColumns: params.health ? statusHealthColumns : void 0,
+		healthRows: params.health ? buildStatusHealthRows({
+			health: params.health,
+			formatHealthChannelLines: params.formatHealthChannelLines,
+			ok: params.ok,
+			warn: params.warn,
+			muted: params.muted
+		}) : void 0,
+		usageLines: params.usageLines,
+		footerLines: buildStatusFooterLines({
+			updateHint: params.formatUpdateAvailableHint(params.surface.update),
+			warn: params.theme.warn,
+			formatCliCommand: params.formatCliCommand,
+			nodeOnlyGateway: params.surface.nodeOnlyGateway,
+			gatewayReachable: params.surface.gatewayReachable
+		})
+	};
+}
+//#endregion
+//#region src/commands/status.command-report.ts
+async function buildStatusCommandReportLines(params) {
+	const lines = [];
+	lines.push(params.heading("Genesis status"));
+	appendStatusReportSections({
+		lines,
+		heading: params.heading,
+		sections: [
+			{ ...buildStatusOverviewSection({
+				width: params.width,
+				renderTable: params.renderTable,
+				rows: params.overviewRows
+			}) },
+			{
+				kind: "raw",
+				body: params.showTaskMaintenanceHint ? ["", params.muted(params.taskMaintenanceHint)] : [],
+				skipIfEmpty: true
+			},
+			{
+				kind: "lines",
+				title: "Plugin compatibility",
+				body: params.pluginCompatibilityLines,
+				skipIfEmpty: true
+			},
+			{
+				kind: "raw",
+				body: params.pairingRecoveryLines.length > 0 ? ["", ...params.pairingRecoveryLines] : [],
+				skipIfEmpty: true
+			},
+			{
+				kind: "lines",
+				title: "Security audit",
+				body: params.securityAuditLines
+			},
+			{ ...buildStatusChannelsTableSection({
+				width: params.width,
+				renderTable: params.renderTable,
+				columns: params.channelsColumns,
+				rows: params.channelsRows
+			}) },
+			{ ...buildStatusSessionsSection({
+				width: params.width,
+				renderTable: params.renderTable,
+				columns: params.sessionsColumns,
+				rows: params.sessionsRows
+			}) },
+			{ ...buildStatusSystemEventsSection({
+				width: params.width,
+				renderTable: params.renderTable,
+				rows: params.systemEventsRows,
+				trailer: params.systemEventsTrailer
+			}) },
+			{ ...buildStatusHealthSection({
+				width: params.width,
+				renderTable: params.renderTable,
+				columns: params.healthColumns,
+				rows: params.healthRows
+			}) },
+			{ ...buildStatusUsageSection({ usageLines: params.usageLines }) },
+			{
+				kind: "raw",
+				body: ["", ...params.footerLines]
+			}
+		]
+	});
+	return lines;
+}
+//#endregion
+//#region src/commands/status.command.ts
+let statusScanModulePromise;
+let statusScanFastJsonModulePromise;
+let statusAllModulePromise;
+let statusCommandTextRuntimePromise;
+let statusGatewayConnectionRuntimePromise;
+let statusNodeModeModulePromise;
+function loadStatusScanModule() {
+	statusScanModulePromise ??= import("./status.scan-CPCLfxhs.js");
+	return statusScanModulePromise;
+}
+function loadStatusScanFastJsonModule() {
+	statusScanFastJsonModulePromise ??= import("./status.scan.fast-json-BlK1NH9B.js");
+	return statusScanFastJsonModulePromise;
+}
+function loadStatusAllModule() {
+	statusAllModulePromise ??= import("./status-all-CyMiAz9D.js");
+	return statusAllModulePromise;
+}
+function loadStatusCommandTextRuntime() {
+	statusCommandTextRuntimePromise ??= import("./status.command.text-runtime-BGkgcMEy.js");
+	return statusCommandTextRuntimePromise;
+}
+function loadStatusGatewayConnectionRuntime() {
+	statusGatewayConnectionRuntimePromise ??= import("./status.gateway-connection.runtime-CAujaH_M.js");
+	return statusGatewayConnectionRuntimePromise;
+}
+function loadStatusNodeModeModule() {
+	statusNodeModeModulePromise ??= import("./status.node-mode-RMI48SQo.js");
+	return statusNodeModeModulePromise;
+}
+function resolvePairingRecoveryContext(params) {
+	const structured = readPairingConnectErrorDetails(params.details);
+	if (structured) return {
+		requestId: normalizePairingConnectRequestId(structured.requestId) ?? null,
+		reason: structured.reason ?? null,
+		remediationHint: structured.remediationHint ? sanitizeTerminalText(structured.remediationHint) : null
+	};
+	const pairing = readConnectPairingRequiredMessage([params.error, params.closeReason].filter((part) => typeof part === "string" && part.trim().length > 0).join(" "));
+	if (!pairing) return null;
+	return {
+		requestId: normalizePairingConnectRequestId(pairing.requestId) ?? null,
+		reason: pairing.reason ?? null,
+		remediationHint: null
+	};
+}
+async function statusCommand(opts, runtime) {
+	if (opts.all && !opts.json) {
+		await loadStatusAllModule().then(({ statusAllCommand }) => statusAllCommand(runtime, { timeoutMs: opts.timeoutMs }));
+		return;
+	}
+	if (opts.json) {
+		await runStatusJsonCommand({
+			opts,
+			runtime,
+			includeSecurityAudit: opts.all === true,
+			includePluginCompatibility: true,
+			suppressHealthErrors: true,
+			scanStatusJsonFast: async (scanOpts, runtimeForScan) => await loadStatusScanFastJsonModule().then(({ scanStatusJsonFast }) => scanStatusJsonFast(scanOpts, runtimeForScan))
+		});
+		return;
+	}
+	const scan = await loadStatusScanModule().then(({ scanStatus }) => scanStatus({
+		json: false,
+		timeoutMs: opts.timeoutMs,
+		all: opts.all
+	}, runtime));
+	const { cfg, osSummary, tailscaleMode, tailscaleDns, tailscaleHttpsUrl, update, gatewayConnection, remoteUrlMissing, gatewayMode, gatewayProbeAuth, gatewayProbeAuthWarning, gatewayProbe, gatewayReachable, gatewaySelf, channelIssues, agentStatus, channels, summary, secretDiagnostics, memory, memoryPlugin, pluginCompatibility } = scan;
+	const { securityAudit, usage, health, gatewayService: daemon, nodeService: nodeDaemon } = await resolveStatusRuntimeSnapshot({
+		config: scan.cfg,
+		sourceConfig: scan.sourceConfig,
+		timeoutMs: opts.timeoutMs,
+		usage: opts.usage,
+		deep: opts.deep,
+		gatewayReachable,
+		includeSecurityAudit: true,
+		resolveSecurityAudit: async (input) => await withProgress({
+			label: "Running security audit…",
+			indeterminate: true,
+			enabled: true
+		}, async () => await resolveStatusSecurityAudit(input)),
+		resolveUsage: async (timeoutMs) => await withProgress({
+			label: "Fetching usage snapshot…",
+			indeterminate: true,
+			enabled: opts.json !== true
+		}, async () => await resolveStatusUsageSummary(timeoutMs)),
+		resolveHealth: async (input) => await withProgress({
+			label: "Checking gateway health…",
+			indeterminate: true,
+			enabled: opts.json !== true
+		}, async () => await resolveStatusGatewayHealth(input))
+	});
+	const { buildStatusUpdateSurface, formatCliCommand, formatHealthChannelLines, formatKTokens, formatPromptCacheCompact, formatPluginCompatibilityNotice, formatTimeAgo, formatTokensCompact, formatUpdateAvailableHint, getTerminalTableWidth, info, renderTable, resolveMemoryCacheSummary, resolveMemoryFtsState, resolveMemoryVectorState, shortenText, theme } = await loadStatusCommandTextRuntime();
+	const muted = (value) => theme.muted(value);
+	const ok = (value) => theme.success(value);
+	const warn = (value) => theme.warn(value);
+	const updateSurface = buildStatusUpdateSurface({
+		updateConfigChannel: cfg.update?.channel,
+		update
+	});
+	if (opts.verbose) {
+		const { buildGatewayConnectionDetails } = await loadStatusGatewayConnectionRuntime();
+		logGatewayConnectionDetails({
+			runtime,
+			info,
+			message: buildGatewayConnectionDetails({ config: scan.cfg }).message,
+			trailingBlankLine: true
+		});
+	}
+	const tableWidth = getTerminalTableWidth();
+	if (secretDiagnostics.length > 0) {
+		runtime.log(theme.warn("Secret diagnostics:"));
+		for (const entry of secretDiagnostics) runtime.log(`- ${entry}`);
+		runtime.log("");
+	}
+	const nodeOnlyGateway = await loadStatusNodeModeModule().then(({ resolveNodeOnlyGatewayInfo }) => resolveNodeOnlyGatewayInfo({
+		daemon,
+		node: nodeDaemon
+	}));
+	const pairingRecovery = resolvePairingRecoveryContext({
+		error: gatewayProbe?.error ?? null,
+		closeReason: gatewayProbe?.close?.reason ?? null,
+		details: gatewayProbe?.connectErrorDetails
+	});
+	const usageLines = usage ? await loadStatusProviderUsageModule().then(({ formatUsageReportLines }) => formatUsageReportLines(usage)) : void 0;
+	const lines = await buildStatusCommandReportLines(await buildStatusCommandReportData({
+		opts,
+		surface: buildStatusOverviewSurfaceFromScan({
+			scan: {
+				cfg,
+				update,
+				tailscaleMode,
+				tailscaleDns,
+				tailscaleHttpsUrl,
+				gatewayMode,
+				remoteUrlMissing,
+				gatewayConnection,
+				gatewayReachable,
+				gatewayProbe,
+				gatewayProbeAuth,
+				gatewayProbeAuthWarning,
+				gatewaySelf
+			},
+			gatewayService: daemon,
+			nodeService: nodeDaemon,
+			nodeOnlyGateway
+		}),
+		osSummary,
+		summary,
+		securityAudit,
+		health,
+		usageLines,
+		agentStatus,
+		channels,
+		channelIssues,
+		memory,
+		memoryPlugin,
+		pluginCompatibility,
+		pairingRecovery,
+		tableWidth,
+		ok,
+		warn,
+		muted,
+		shortenText,
+		formatCliCommand,
+		formatTimeAgo,
+		formatKTokens,
+		formatTokensCompact,
+		formatPromptCacheCompact,
+		formatHealthChannelLines,
+		formatPluginCompatibilityNotice,
+		formatUpdateAvailableHint,
+		resolveMemoryVectorState,
+		resolveMemoryFtsState,
+		resolveMemoryCacheSummary,
+		accentDim: theme.accentDim,
+		theme,
+		renderTable,
+		updateValue: updateSurface.updateAvailable ? warn(`available · ${updateSurface.updateLine}`) : updateSurface.updateLine
+	}));
+	for (const line of lines) runtime.log(line);
+}
+//#endregion
+export { statusCommand as t };