@pixelzx/genesis 2026.6.27 → 2026.6.29

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

@@ -0,0 +1,241 @@
+import { n as readGatewayServiceState, r as resolveGatewayService } from "./service-DiHWY6iI.js";
+import { n as resolveReadOnlyChannelPluginsForConfig } from "./read-only-B2cFHgh2.js";
+import { t as resolveNodeService } from "./node-service-DLWVCdMw.js";
+import { a as buildStatusOverviewSurfaceRows, t as buildGatewayStatusJsonPayload } from "./format-OOnBOcRX.js";
+import { t as formatDaemonRuntimeShort } from "./status.format-CHwDgJN2.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-Bh9mhi3s.js");
+	return providerUsagePromise;
+}
+function loadSecurityAuditModule() {
+	securityAuditModulePromise ??= import("./audit.runtime-DYyjmKuk.js");
+	return securityAuditModulePromise;
+}
+function loadGatewayCallModule() {
+	gatewayCallModulePromise ??= import("./call-S0AZ899k.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 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 [gatewayService, nodeService] = await resolveStatusServiceSummaries();
+	return {
+		usage,
+		health,
+		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-VTEVgOJj.js

@@ -0,0 +1,18 @@
+import { i as countPendingDescendantRuns } from "./subagent-registry-CruvknDh.js";
+import { o as resolveSubagentLabel } from "./subagents-format-CqbR_pUY.js";
+import { o as listControlledSubagentRuns } from "./subagent-control-CMaKDVuG.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-DHuvJr3p.js";
+export * from "./status-subagents.runtime-VTEVgOJj.js";

package/dist/status-text-Cx0Esdj6.js

@@ -0,0 +1,237 @@
+import { s as normalizeOptionalLowercaseString } from "./string-coerce-DPP_aYVc.js";
+import { r as toAgentModelListLike } from "./model-input-gXkzehoL.js";
+import { _ as resolveAgentConfig, p as resolveSessionAgentId, s as resolveAgentModelFallbacksOverride, x as resolveDefaultAgentId, y as resolveAgentDir } from "./agent-scope-BUYwVohk.js";
+import { i as selectAgentHarness } from "./selection-D_K-9r-x.js";
+import { n as formatTaskStatusDetail, r as formatTaskStatusTitle, t as buildTaskStatusSnapshot } from "./task-status-CQv7hAk3.js";
+import { m as listTasksForSessionKey, u as listTasksForAgentId } from "./task-registry-CKDRlfmp.js";
+import { o as resolveInternalSessionKey, s as resolveMainSessionAlias } from "./sessions-helpers-DlsDzSXL.js";
+import { t as normalizeGroupActivation } from "./group-activation-BiaHgDAZ.js";
+import { t as resolveFastModeState } from "./fast-mode-CjapnL6q.js";
+import { t as resolveModelAuthLabel } from "./model-auth-label-Cs27jzSW.js";
+import { o as resolveUsageProviderId } from "./provider-usage.shared-DY9OR56X.js";
+import { n as resolveSelectedAndActiveModel } from "./model-runtime-BMKGhZxR.js";
+import { r as formatUsageWindowSummary } from "./provider-usage-DF2iR-WB.js";
+import { t as loadProviderUsageSummary } from "./provider-usage.load-DgZeLYLg.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-BnLXbVHh.js").then((module) => module.loadStatusMessageRuntimeModule());
+}
+function loadStatusSubagentsRuntime() {
+	return statusSubagentsRuntimePromise ??= import("./status-subagents.runtime-VTEVgOJj.js");
+}
+function loadStatusQueueRuntime() {
+	return statusQueueRuntimePromise ??= import("./status-queue.runtime-DXdIwJaQ.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-xjF4vxou.js

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

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

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

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

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