// Status text helpers render runtime status summaries for CLI output.

import os from "node:os";

import { normalizeOptionalLowercaseString } from "@openclaw/normalization-core/string-coerce";

import {

resolveAgentConfig,

resolveAgentDir,

resolveAgentWorkspaceDir,

resolveDefaultAgentId,

resolveSessionAgentId,

resolveAgentModelFallbacksOverride,

} from "../agents/agent-scope.js";

import { ensureAuthProfileStore } from "../agents/auth-profiles/store.js";

import { resolveContextTokensForModel } from "../agents/context.js";

import { resolveFastModeState } from "../agents/fast-mode.js";

import { resolveModelAuthLabel } from "../agents/model-auth-label.js";

import { CODEX_APP_SERVER_AUTH_MARKER } from "../agents/model-auth-markers.js";

import {

areRuntimeModelRefsEquivalent,

shouldPreferActiveRuntimeAliasAuthLabel,

} from "../agents/model-runtime-aliases.js";

import { resolveDefaultModelForAgent } from "../agents/model-selection.js";

import { listOpenAIAuthProfileProvidersForAgentRuntime } from "../agents/openai-routing.js";

import { resolveProviderIdForAuth } from "../agents/provider-auth-aliases.js";

import {

resolveInternalSessionKey,

resolveMainSessionAlias,

} from "../agents/tools/sessions-helpers.js";

import { normalizeGroupActivation } from "../auto-reply/group-activation.js";

import { resolveSelectedAndActiveModel } from "../auto-reply/model-runtime.js";

import type { ThinkLevel } from "../auto-reply/thinking.js";

import { toAgentModelListLike } from "../config/model-input.js";

import type { SessionEntry } from "../config/sessions.js";

import { hasSessionAutoModelFallbackProvenance } from "../config/sessions/model-override-provenance.js";

import type { OpenClawConfig } from "../config/types.openclaw.js";

import { formatDurationCompact } from "../infra/format-time/format-duration.ts";

import {

formatUsageWindowSummary,

loadProviderUsageSummary,

resolveUsageProviderId,

} from "../infra/provider-usage.js";

import {

listTasksForAgentIdForStatus,

listTasksForSessionKeyForStatus,

} from "../tasks/task-status-access.js";

import {

buildTaskStatusSnapshot,

formatTaskStatusDetail,

formatTaskStatusTitle,

} from "../tasks/task-status.js";

import type { BuildStatusTextParams } from "./status-text.types.js";

export type { BuildStatusTextParams } from "./status-text.types.js";

// Status text assembly gathers runtime/model/session/task facts, then delegates

// final formatting to status-message.runtime through lazy imports.

const USAGE_OAUTH_ONLY_PROVIDERS = new Set([

"anthropic",

"github-copilot",

"google-gemini-cli",

"openai",

]);

let statusMessageRuntimePromise: Promise<typeof import("../auto-reply/status.runtime.js")> | null =

null;

let agentHarnessSelectionRuntimePromise: Promise<

typeof import("../agents/harness/selection.js")

> | null = null;

let statusQueueRuntimePromise: Promise<typeof import("./status-queue.runtime.js")> | null = null;

let statusSubagentsRuntimePromise: Promise<typeof import("./status-subagents.runtime.js")> | null =

null;

function loadStatusMessageRuntime(): Promise<typeof import("../auto-reply/status.runtime.js")> {

const runtimePromise = (statusMessageRuntimePromise ??=

import("./status-message.runtime.js").then((module) =>

module.loadStatusMessageRuntimeModule(),

));

return runtimePromise;

}

function loadAgentHarnessSelectionRuntime(): Promise<

typeof import("../agents/harness/selection.js")

> {

const runtimePromise = (agentHarnessSelectionRuntimePromise ??=

import("../agents/harness/selection.js"));

return runtimePromise;

}

function loadStatusSubagentsRuntime(): Promise<typeof import("./status-subagents.runtime.js")> {

const runtimePromise = (statusSubagentsRuntimePromise ??=

import("./status-subagents.runtime.js"));

return runtimePromise;

}

function loadStatusQueueRuntime(): Promise<typeof import("./status-queue.runtime.js")> {

const runtimePromise = (statusQueueRuntimePromise ??= import("./status-queue.runtime.js"));

return runtimePromise;

}

// Context lookup stays synchronous/non-refreshing so status output does not

// trigger provider/catalog IO while rendering a command response.

function resolveStatusRuntimeContextTokens(params: {

cfg: OpenClawConfig;

provider: string;

model: string;

}): number | undefined {

return resolveContextTokensForModel({

cfg: params.cfg,

provider: params.provider,

model: params.model,

allowAsyncLoad: false,

});

}

function shouldLoadUsageSummary(params: {

provider?: string;

selectedModelAuth?: string;

credentialType?: string;

}): boolean {

if (!params.provider) {

return false;

}

if (!USAGE_OAUTH_ONLY_PROVIDERS.has(params.provider)) {

return true;

}

// OAuth/token usage endpoints are meaningful only for providers authenticated

// through those modes; skip API-key sessions to avoid slow unavailable calls.

const auth = normalizeOptionalLowercaseString(params.selectedModelAuth);

return Boolean(

params.credentialType === "oauth" ||

params.credentialType === "token" ||

auth?.startsWith("oauth") ||

auth?.startsWith("token"),

);

}

function resolveUsageCredentialType(authLabel?: string): "oauth" | "token" | "api_key" | undefined {

const auth = normalizeOptionalLowercaseString(authLabel);

if (!auth) {

return undefined;

}

if (auth.startsWith("oauth")) {

return "oauth";

}

if (auth.startsWith("token")) {

return "token";

}

if (auth.startsWith("api-key") || auth.startsWith("api key")) {

return "api_key";

}

return undefined;

}

function resolveCodexSyntheticUsageAuthProfileId(params: {

profileId: string | undefined;

cfg: OpenClawConfig;

agentDir?: string;

}): string | undefined {

const normalizedProfileId = params.profileId?.trim();

if (!normalizedProfileId) {

return undefined;

}

try {

const store = ensureAuthProfileStore(params.agentDir, {

allowKeychainPrompt: false,

config: params.cfg,

readOnly: true,

syncExternalCli: false,

});

const credential = store.profiles[normalizedProfileId];

if (!credential) {

return undefined;

}

const credentialProvider = normalizeOptionalLowercaseString(credential.provider);

const resolvedProvider = resolveProviderIdForAuth(credential.provider, { config: params.cfg });

return resolvedProvider === "openai" ||

credentialProvider === "openai-codex" ||

credentialProvider === "codex-cli"

? normalizedProfileId

: undefined;

} catch {

return undefined;

}

}

function shouldUseCodexSyntheticUsage(params: {

provider?: string;

effectiveHarness?: string;

}): boolean {

const harness = normalizeOptionalLowercaseString(params.effectiveHarness);

const provider = normalizeOptionalLowercaseString(params.provider);

return harness === "codex" && (provider === "openai" || provider === "codex");

}

function formatSessionTaskLine(sessionKey: string): string | undefined {

const snapshot = buildTaskStatusSnapshot(listTasksForSessionKeyForStatus(sessionKey));

const task = snapshot.focus;

if (!task) {

return undefined;

}

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(" · ")}` : undefined;

}

async function resolveStatusHarnessId(params: {

cfg: OpenClawConfig;

provider: string;

model: string;

agentId: string;

sessionKey: string;

sessionEntry?: SessionEntry;

}): Promise<string | undefined> {

try {

const { selectAgentHarness } = await loadAgentHarnessSelectionRuntime();

const selected = selectAgentHarness({

provider: params.provider,

modelId: params.model,

config: params.cfg,

agentId: params.agentId,

sessionKey: params.sessionKey,

agentHarnessId: params.sessionEntry?.agentHarnessId,

});

const id = normalizeOptionalLowercaseString(selected.id);

return id || undefined;

} catch {

// Harness selection is nice-to-have for display. Status should still render

// if dynamic harness modules are unavailable.

return undefined;

}

}

function resolveStatusRuntimeProvider(params: {

provider: string;

effectiveHarness?: string;

}): string {

const harness = normalizeOptionalLowercaseString(params.effectiveHarness);

const provider = normalizeOptionalLowercaseString(params.provider);

if (harness === "codex" && (provider === "openai" || provider === "codex")) {

return "openai";

}

if (harness === "claude-cli" && provider === "anthropic") {

return "claude-cli";

}

return params.provider;

}

function formatAgentTaskCountsLine(agentId: string): string | undefined {

const snapshot = buildTaskStatusSnapshot(listTasksForAgentIdForStatus(agentId));

if (snapshot.totalCount === 0) {

return undefined;

}

return `📌 Tasks: ${snapshot.activeCount} active · ${snapshot.totalCount} total · agent-local`;

}

function formatStatusUptimeDuration(ms: number): string {

return formatDurationCompact(ms, { spaced: true }) ?? "0s";

}

export function buildStatusUptimeLine(): string {

const gatewayUptimeMs = Math.max(0, Math.round(process.uptime() * 1000));

const systemUptimeMs = Math.max(0, Math.round(os.uptime() * 1000));

return `⏱️ Uptime: gateway ${formatStatusUptimeDuration(gatewayUptimeMs)} · system ${formatStatusUptimeDuration(systemUptimeMs)}`;

}

// Public status text builder for CLI/chat status commands. It resolves dynamic

// runtime details just-in-time and returns the formatted multiline status body.

export async function buildStatusText(params: BuildStatusTextParams): Promise<string> {

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;

const runtimeAliasModelEquivalent = areRuntimeModelRefsEquivalent(

modelRefs.selected.label,

modelRefs.active.label,

{ config: cfg },

);

if (

shouldPreferActiveRuntimeAliasAuthLabel({

runtimeAliasModelEquivalent,

selectedAuthLabel: selectedModelAuth,

activeAuthLabel: activeModelAuth,

})

) {

// Runtime aliases can make selected/active model refs equivalent while auth

// labels differ; prefer the active auth label so status matches execution.

selectedModelAuth = activeModelAuth;

}

const usageAuthLabel = modelRefs.activeDiffers ? activeModelAuth : selectedModelAuth;

const selectedUsageCredentialType = resolveUsageCredentialType(usageAuthLabel);

const useCodexSyntheticUsage =

shouldUseCodexSyntheticUsage({

provider: activeStatusProvider,

effectiveHarness,

}) &&

(selectedUsageCredentialType === "oauth" || selectedUsageCredentialType === "token");

const codexUsageAuthProfileId = useCodexSyntheticUsage

? resolveCodexSyntheticUsageAuthProfileId({

profileId: sessionEntry?.authProfileOverride,

cfg,

agentDir: statusAgentDir,

})

: undefined;

const usageCredentialType = useCodexSyntheticUsage ? "token" : selectedUsageCredentialType;

const currentUsageProvider =

resolveUsageProviderId(activeStatusProvider, { credentialType: usageCredentialType }) ??

resolveUsageProviderId(activeProvider, { credentialType: usageCredentialType });

let usageLine: string | null = null;

if (

currentUsageProvider &&

shouldLoadUsageSummary({

provider: currentUsageProvider,

selectedModelAuth: usageAuthLabel,

credentialType: usageCredentialType,

})

) {

try {

// Usage summary is optional operator context. Bound it tightly so a slow

// provider usage probe cannot delay the status command.

const usageSummaryTimeoutMs = useCodexSyntheticUsage ? 8000 : 3500;

let usageTimeout: NodeJS.Timeout | undefined;

const usageSummary = await Promise.race([

loadProviderUsageSummary({

timeoutMs: usageSummaryTimeoutMs,

providers: [currentUsageProvider],

agentDir: statusAgentDir,

workspaceDir: statusWorkspaceDir,

config: cfg,

auth: useCodexSyntheticUsage

? [

{

provider: "openai",

token: CODEX_APP_SERVER_AUTH_MARKER,

...(codexUsageAuthProfileId ? { authProfileId: codexUsageAuthProfileId } : {}),

hookProvider: "codex",

},

]

: undefined,

}),

new Promise<never>((_, reject) => {

usageTimeout = setTimeout(

() => reject(new Error("usage summary timeout")),

usageSummaryTimeoutMs,

);

}),

]).finally(() => {

if (usageTimeout) {

clearTimeout(usageTimeout);

}

});

const usageEntry = usageSummary.providers[0];

if (

usageEntry &&

!usageEntry.error &&

(usageEntry.windows.length > 0 || Boolean(usageEntry.summary?.trim()))

) {

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: string | undefined;

let taskLine: string | undefined;

if (sessionKey) {

const { mainKey, alias } = resolveMainSessionAlias(cfg);

const requesterKey = resolveInternalSessionKey({ key: sessionKey, alias, mainKey });

// Task/subagent status should follow the internal session key alias used by

// runtime registries, not necessarily the external key passed to the command.

taskLine = params.skipDefaultTaskLookup

? params.taskLineOverride

: (params.taskLineOverride ?? formatSessionTaskLine(requesterKey));

if (!taskLine && !params.skipDefaultTaskLookup) {

taskLine = formatAgentTaskCountsLine(statusAgentId);

}

const { buildSubagentsStatusLine, countPendingDescendantRuns, listControlledSubagentRuns } =

await loadStatusSubagentsRuntime();

const runs = listControlledSubagentRuns(requesterKey);

const verboseEnabled = resolvedVerboseLevel && resolvedVerboseLevel !== "off";

subagentsLine = buildSubagentsStatusLine({

runs,

verboseEnabled,

pendingDescendantsForRun: (entry) => countPendingDescendantRuns(entry.childSessionKey),

});

}

const groupActivation = isGroup

? (normalizeGroupActivation(sessionEntry?.groupActivation) ?? defaultGroupActivation())

: undefined;

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 as ThinkLevel | undefined) ??

(agentDefaults.thinkingDefault as ThinkLevel | undefined);

const configuredContextTokens =

typeof agentConfig?.contextTokens === "number" && agentConfig.contextTokens > 0

? agentConfig.contextTokens

: typeof agentDefaults.contextTokens === "number" && agentDefaults.contextTokens > 0

? agentDefaults.contextTokens

: undefined;

const runtimeContextTokens = resolveStatusRuntimeContextTokens({

cfg,

provider: activeStatusProvider,

model: modelRefs.active.model || model,

});

const selectedContextTokens = resolveStatusRuntimeContextTokens({

cfg,

provider: selectedStatusProvider,

model,

});

const runtimeSnapshotHasFallbackProvenance =

!modelRefs.activeDiffers ||

hasSessionAutoModelFallbackProvenance(sessionEntry) ||

areRuntimeModelRefsEquivalent(modelRefs.active.label, modelRefs.selected.label, {

config: cfg,

});

const statusAgentContextTokens =

typeof contextTokens === "number" &&

contextTokens > 0 &&

(runtimeSnapshotHasFallbackProvenance ||

contextTokens === configuredContextTokens ||

contextTokens === selectedContextTokens)

? contextTokens

: undefined;

const statusRuntimeContextTokens = runtimeSnapshotHasFallbackProvenance

? runtimeContextTokens

: undefined;

return buildStatusMessage({

config: cfg,

agent: {

...agentDefaults,

model: {

...toAgentModelListLike(agentDefaults.model),

primary: params.primaryModelLabelOverride ?? `${provider}/${model}`,

...(agentFallbacksOverride === undefined ? {} : { fallbacks: agentFallbacksOverride }),

},

...(statusAgentContextTokens !== undefined

? { contextTokens: statusAgentContextTokens }

: {}),

thinkingDefault: explicitThinkingDefault,

verboseDefault: agentDefaults.verboseDefault,

reasoningDefault: agentConfig?.reasoningDefault ?? agentDefaults.reasoningDefault,

elevatedDefault: agentDefaults.elevatedDefault,

},

agentId: statusAgentId,

configuredDefaultModelLabel,

explicitConfiguredContextTokens: configuredContextTokens,

runtimeContextTokens: statusRuntimeContextTokens,

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 ?? undefined,

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,

});

}