@gaodefa/daocore 2026.5.48 → 2026.5.51

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

@@ -0,0 +1,283 @@
+import { t as createLazyImportLoader } from "./lazy-promise-Djskx0qC.js";
+import "./agent-scope-Dx1S0aWX.js";
+import { s as resolveDefaultAgentDir } from "./agent-scope-config-CJUQxn7u.js";
+import { i as resolveGatewayService, r as readGatewayServiceState } from "./service-BJz1apuv.js";
+import { r as resolveReadOnlyChannelPluginsForConfig } from "./read-only-4EUNXClZ.js";
+import { t as resolveNodeService } from "./node-service-BpK3SC41.js";
+import { t as summarizeGatewayServiceLayout } from "./service-layout-EdjNiu4j.js";
+import { a as buildStatusOverviewSurfaceRows, t as buildGatewayStatusJsonPayload } from "./format-DCronAhx.js";
+import { t as formatDaemonRuntimeShort } from "./status.format-DMoa2-sH.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 layout = await summarizeGatewayServiceLayout(state.command);
+		const managedByDaoCore = state.installed;
+		const externallyManaged = !managedByDaoCore && state.running;
+		const installed = managedByDaoCore || externallyManaged;
+		const loadedText = externallyManaged ? "running (externally managed)" : state.loaded ? service.loadedText : service.notLoadedText;
+		return {
+			label: service.label,
+			installed,
+			loaded: state.loaded,
+			managedByDaoCore,
+			externallyManaged,
+			loadedText,
+			runtime: state.runtime,
+			...layout ? { layout } : {}
+		};
+	} catch {
+		return {
+			label: fallbackLabel,
+			installed: null,
+			loaded: false,
+			managedByDaoCore: 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,
+		managedByDaoCore: summary.managedByDaoCore,
+		externallyManaged: summary.externallyManaged,
+		loadedText: summary.loadedText,
+		runtime: summary.runtime,
+		runtimeShort: formatDaemonRuntimeShort(summary.runtime),
+		layout: summary.layout
+	};
+}
+async function getDaemonStatusSummary() {
+	return await buildDaemonStatusSummary("gateway");
+}
+async function getNodeDaemonStatusSummary() {
+	return await buildDaemonStatusSummary("node");
+}
+//#endregion
+//#region src/commands/status-runtime-shared.ts
+const providerUsageLoader = createLazyImportLoader(() => import("./provider-usage-Dy9Yusev.js"));
+const securityAuditModuleLoader = createLazyImportLoader(() => import("./audit.runtime.js"));
+const gatewayCallModuleLoader = createLazyImportLoader(() => import("./call-mS4UpZAV.js"));
+function loadProviderUsage() {
+	return providerUsageLoader.load();
+}
+function loadSecurityAuditModule() {
+	return securityAuditModuleLoader.load();
+}
+function loadGatewayCallModule() {
+	return gatewayCallModuleLoader.load();
+}
+async function resolveStatusSecurityAudit(params) {
+	const { runSecurityAudit } = await loadSecurityAuditModule();
+	const readOnlyPlugins = resolveReadOnlyChannelPluginsForConfig(params.config, {
+		activationSourceConfig: params.sourceConfig,
+		includeSetupFallbackPlugins: false
+	});
+	return await runSecurityAudit({
+		config: params.config,
+		sourceConfig: params.sourceConfig,
+		deep: false,
+		includeFilesystem: true,
+		includeChannelSecurity: true,
+		loadPluginSecurityCollectors: false,
+		...readOnlyPlugins.missingConfiguredChannelIds.length === 0 ? { plugins: readOnlyPlugins.plugins } : {}
+	});
+}
+async function resolveStatusUsageSummary(params) {
+	const { loadProviderUsageSummary } = await loadProviderUsage();
+	return await loadProviderUsageSummary({
+		timeoutMs: params.timeoutMs,
+		config: params.config,
+		agentDir: params.agentDir ?? resolveDefaultAgentDir(params.config)
+	});
+}
+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 resolveStatusGatewayDiagnosticsSafe(params) {
+	if (!params.gatewayReachable) return null;
+	const { callGateway } = await loadGatewayCallModule();
+	return await callGateway({
+		method: "diagnostics.stability",
+		params: { limit: 1e3 },
+		timeoutMs: params.timeoutMs,
+		config: params.config,
+		...params.callOverrides
+	}).catch(() => null);
+}
+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({
+		timeoutMs: params.timeoutMs,
+		config: params.config
+	}) : 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 { resolveStatusRuntimeSnapshot as a, resolveStatusUsageSummary as c, buildStatusOverviewSurfaceFromOverview as d, buildStatusOverviewSurfaceFromScan as f, resolveStatusGatewayHealthSafe as i, buildStatusGatewayJsonPayloadFromSurface as l, resolveStatusGatewayDiagnosticsSafe as n, resolveStatusSecurityAudit as o, resolveStatusGatewayHealth as r, resolveStatusServiceSummaries as s, loadStatusProviderUsageModule as t, buildStatusOverviewRowsFromSurface as u };

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

@@ -0,0 +1,18 @@
+import { i as countPendingDescendantRuns } from "./subagent-registry-Ct9aaUSq.js";
+import { r as resolveSubagentLabel } from "./subagents-utils-yfXEDHe3.js";
+import { o as listControlledSubagentRuns } from "./subagent-control-Svp4alxT.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-Dnd_-sFp.js";
+export * from "./status-subagents.runtime-B79dVmOZ.js";

package/dist/status-text-CNV3Xo_z.js

@@ -0,0 +1,296 @@
+import { s as normalizeOptionalLowercaseString } from "./string-coerce-DyL154ka.js";
+import { o as toAgentModelListLike } from "./model-input-ChW9XXsQ.js";
+import { _ as resolveSessionAgentId, u as resolveAgentModelFallbacksOverride } from "./agent-scope-Dx1S0aWX.js";
+import { a as resolveAgentDir, c as resolveDefaultAgentId, o as resolveAgentWorkspaceDir, r as resolveAgentConfig } from "./agent-scope-config-CJUQxn7u.js";
+import { a as listOpenAIAuthProfileProvidersForAgentRuntime } from "./openai-codex-routing-VOt1IwnF.js";
+import { s as resolveDefaultModelForAgent } from "./model-selection-D1TyOrqK.js";
+import { n as formatTaskStatusDetail, r as formatTaskStatusTitle, t as buildTaskStatusSnapshot } from "./task-status-DOEIqFXg.js";
+import { o as resolveContextTokensForModel } from "./context-BK8i6-zU.js";
+import { t as formatDurationCompact } from "./format-duration-BrZ-AaEJ.js";
+import { c as resolveMainSessionAlias, s as resolveInternalSessionKey } from "./sessions-helpers-Ctik-uPl.js";
+import { t as areRuntimeModelRefsEquivalent } from "./model-runtime-aliases-CEDWbZ3S.js";
+import { t as normalizeGroupActivation } from "./group-activation-BxkIP-sT.js";
+import { t as resolveFastModeState } from "./fast-mode-ByjA37ED.js";
+import { t as resolveModelAuthLabel } from "./model-auth-label-DDPZ8sW8.js";
+import { o as resolveUsageProviderId } from "./provider-usage.shared-DlwThvoV.js";
+import { n as resolveSelectedAndActiveModel } from "./model-runtime-NSmvD3mm.js";
+import { i as formatUsageWindowSummary, t as loadProviderUsageSummary } from "./provider-usage-xMPZL_dv.js";
+import { n as listTasksForAgentIdForStatus, r as listTasksForSessionKeyForStatus } from "./task-status-access-Dirbx-QC.js";
+import os from "node:os";
+//#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 agentHarnessSelectionRuntimePromise = null;
+let statusQueueRuntimePromise = null;
+let statusSubagentsRuntimePromise = null;
+function loadStatusMessageRuntime() {
+	return statusMessageRuntimePromise ??= import("./status-message.runtime.js").then((module) => module.loadStatusMessageRuntimeModule());
+}
+function loadAgentHarnessSelectionRuntime() {
+	return agentHarnessSelectionRuntimePromise ??= import("./selection-Cp7REh-j.js");
+}
+function loadStatusSubagentsRuntime() {
+	return statusSubagentsRuntimePromise ??= import("./status-subagents.runtime.js");
+}
+function loadStatusQueueRuntime() {
+	return statusQueueRuntimePromise ??= import("./status-queue.runtime.js");
+}
+function resolveStatusRuntimeContextTokens(params) {
+	return resolveContextTokensForModel({
+		cfg: params.cfg,
+		provider: params.provider,
+		model: params.model,
+		allowAsyncLoad: false
+	});
+}
+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;
+}
+async function resolveStatusHarnessId(params) {
+	try {
+		const { selectAgentHarness } = await loadAgentHarnessSelectionRuntime();
+		return normalizeOptionalLowercaseString(selectAgentHarness({
+			provider: params.provider,
+			modelId: params.model,
+			config: params.cfg,
+			agentId: params.agentId,
+			sessionKey: params.sessionKey,
+			agentHarnessId: params.sessionEntry?.agentHarnessId
+		}).id) || void 0;
+	} catch {
+		return;
+	}
+}
+function resolveStatusRuntimeProvider(params) {
+	const harness = normalizeOptionalLowercaseString(params.effectiveHarness);
+	const provider = normalizeOptionalLowercaseString(params.provider);
+	if (harness === "codex" && provider === "openai") return "openai-codex";
+	if (harness === "claude-cli" && provider === "anthropic") return "claude-cli";
+	return params.provider;
+}
+function formatAgentTaskCountsLine(agentId) {
+	const snapshot = buildTaskStatusSnapshot(listTasksForAgentIdForStatus(agentId));
+	if (snapshot.totalCount === 0) return;
+	return `📌 Tasks: ${snapshot.activeCount} active · ${snapshot.totalCount} total · agent-local`;
+}
+function formatStatusUptimeDuration(ms) {
+	return formatDurationCompact(ms, { spaced: true }) ?? "0s";
+}
+function buildStatusUptimeLine() {
+	const gatewayUptimeMs = Math.max(0, Math.round(process.uptime() * 1e3));
+	const systemUptimeMs = Math.max(0, Math.round(os.uptime() * 1e3));
+	return `⏱️ Uptime: gateway ${formatStatusUptimeDuration(gatewayUptimeMs)} · system ${formatStatusUptimeDuration(systemUptimeMs)}`;
+}
+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 statusWorkspaceDir = params.workspaceDir ?? sessionEntry?.spawnedWorkspaceDir ?? resolveAgentWorkspaceDir(cfg, statusAgentId);
+	const modelRefs = resolveSelectedAndActiveModel({
+		selectedProvider: provider,
+		selectedModel: model,
+		sessionEntry
+	});
+	const effectiveHarness = params.resolvedHarness ?? await resolveStatusHarnessId({
+		cfg,
+		provider,
+		model,
+		agentId: statusAgentId,
+		sessionKey,
+		sessionEntry
+	});
+	const selectedStatusProvider = resolveStatusRuntimeProvider({
+		provider,
+		effectiveHarness
+	});
+	const selectedAuthProviders = listOpenAIAuthProfileProvidersForAgentRuntime({
+		provider,
+		harnessRuntime: effectiveHarness,
+		config: cfg
+	});
+	const activeProvider = modelRefs.active.provider || provider;
+	const activeStatusProvider = resolveStatusRuntimeProvider({
+		provider: activeProvider,
+		effectiveHarness
+	});
+	const activeAuthProviders = listOpenAIAuthProfileProvidersForAgentRuntime({
+		provider: activeProvider,
+		harnessRuntime: effectiveHarness,
+		config: cfg
+	});
+	let selectedModelAuth = Object.hasOwn(params, "modelAuthOverride") ? params.modelAuthOverride : resolveModelAuthLabel({
+		provider: selectedStatusProvider,
+		acceptedProviderIds: selectedAuthProviders,
+		cfg,
+		sessionEntry,
+		agentDir: statusAgentDir,
+		workspaceDir: statusWorkspaceDir,
+		includeExternalProfiles: false
+	});
+	const activeModelAuth = Object.hasOwn(params, "activeModelAuthOverride") ? params.activeModelAuthOverride : modelRefs.activeDiffers ? resolveModelAuthLabel({
+		provider: activeStatusProvider,
+		acceptedProviderIds: activeAuthProviders,
+		cfg,
+		sessionEntry,
+		agentDir: statusAgentDir,
+		workspaceDir: statusWorkspaceDir,
+		includeExternalProfiles: false
+	}) : selectedModelAuth;
+	if (areRuntimeModelRefsEquivalent(modelRefs.selected.label, modelRefs.active.label) && normalizeOptionalLowercaseString(selectedModelAuth) === "unknown" && activeModelAuth && normalizeOptionalLowercaseString(activeModelAuth) !== "unknown") selectedModelAuth = activeModelAuth;
+	const usageAuthLabel = modelRefs.activeDiffers ? activeModelAuth : selectedModelAuth;
+	const currentUsageProvider = resolveUsageProviderId(activeStatusProvider) ?? resolveUsageProviderId(activeProvider);
+	let usageLine = null;
+	if (currentUsageProvider && shouldLoadUsageSummary({
+		provider: currentUsageProvider,
+		selectedModelAuth: usageAuthLabel
+	})) 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 agentFallbacksOverride = resolveAgentModelFallbacksOverride(cfg, statusAgentId);
+	const configuredDefaultRef = resolveDefaultModelForAgent({
+		cfg,
+		agentId: statusAgentId,
+		allowPluginNormalization: false
+	});
+	const configuredDefaultModelLabel = `${configuredDefaultRef.provider}/${configuredDefaultRef.model}`;
+	const { buildStatusMessage } = await loadStatusMessageRuntime();
+	const explicitThinkingDefault = agentConfig?.thinkingDefault ?? agentDefaults.thinkingDefault;
+	const runtimeContextTokens = resolveStatusRuntimeContextTokens({
+		cfg,
+		provider: activeStatusProvider,
+		model: modelRefs.active.model || model
+	});
+	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,
+			reasoningDefault: agentConfig?.reasoningDefault ?? agentDefaults.reasoningDefault,
+			elevatedDefault: agentDefaults.elevatedDefault
+		},
+		agentId: statusAgentId,
+		configuredDefaultModelLabel,
+		explicitConfiguredContextTokens: typeof agentDefaults.contextTokens === "number" && agentDefaults.contextTokens > 0 ? agentDefaults.contextTokens : void 0,
+		runtimeContextTokens,
+		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,
+		uptimeLine: buildStatusUptimeLine(),
+		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 { buildStatusText as t };