@takibeiy/moltbot_cn 2026.2.1 → 2026.2.3

package/dist/auto-reply/reply/commands-context.d.ts

@@ -0,0 +1,12 @@
+import type { OpenClawConfig } from "../../config/config.js";
+import type { MsgContext } from "../templating.js";
+import type { CommandContext } from "./commands-types.js";
+export declare function buildCommandContext(params: {
+    ctx: MsgContext;
+    cfg: OpenClawConfig;
+    agentId?: string;
+    sessionKey?: string;
+    isGroup: boolean;
+    triggerBodyNormalized: string;
+    commandAuthorized: boolean;
+}): CommandContext;

package/dist/auto-reply/reply/commands-core.d.ts

@@ -0,0 +1,2 @@
+import type { CommandHandlerResult, HandleCommandsParams } from "./commands-types.js";
+export declare function handleCommands(params: HandleCommandsParams): Promise<CommandHandlerResult>;

package/dist/auto-reply/reply/commands-core.js

@@ -1,44 +1,47 @@
 import { logVerbose } from "../../globals.js";
+import { createInternalHookEvent, triggerInternalHook } from "../../hooks/internal-hooks.js";
 import { resolveSendPolicy } from "../../sessions/send-policy.js";
 import { shouldHandleTextCommands } from "../commands-registry.js";
-import { createInternalHookEvent, triggerInternalHook } from "../../hooks/internal-hooks.js";
-import { routeReply } from "./route-reply.js";
+import { handleAllowlistCommand } from "./commands-allowlist.js";
+import { handleApproveCommand } from "./commands-approve.js";
 import { handleBashCommand } from "./commands-bash.js";
 import { handleCompactCommand } from "./commands-compact.js";
 import { handleConfigCommand, handleDebugCommand } from "./commands-config.js";
 import { handleCommandsListCommand, handleContextCommand, handleHelpCommand, handleStatusCommand, handleWhoamiCommand, } from "./commands-info.js";
-import { handleAllowlistCommand } from "./commands-allowlist.js";
-import { handleApproveCommand } from "./commands-approve.js";
-import { handleSubagentsCommand } from "./commands-subagents.js";
 import { handleModelsCommand } from "./commands-models.js";
-import { handleTtsCommands } from "./commands-tts.js";
-import { handleAbortTrigger, handleActivationCommand, handleRestartCommand, handleSendPolicyCommand, handleStopCommand, handleUsageCommand, } from "./commands-session.js";
 import { handlePluginCommand } from "./commands-plugin.js";
-const HANDLERS = [
-    // Plugin commands are processed first, before built-in commands
-    handlePluginCommand,
-    handleBashCommand,
-    handleActivationCommand,
-    handleSendPolicyCommand,
-    handleUsageCommand,
-    handleRestartCommand,
-    handleTtsCommands,
-    handleHelpCommand,
-    handleCommandsListCommand,
-    handleStatusCommand,
-    handleAllowlistCommand,
-    handleApproveCommand,
-    handleContextCommand,
-    handleWhoamiCommand,
-    handleSubagentsCommand,
-    handleConfigCommand,
-    handleDebugCommand,
-    handleModelsCommand,
-    handleStopCommand,
-    handleCompactCommand,
-    handleAbortTrigger,
-];
+import { handleAbortTrigger, handleActivationCommand, handleRestartCommand, handleSendPolicyCommand, handleStopCommand, handleUsageCommand, } from "./commands-session.js";
+import { handleSubagentsCommand } from "./commands-subagents.js";
+import { handleTtsCommands } from "./commands-tts.js";
+import { routeReply } from "./route-reply.js";
+let HANDLERS = null;
 export async function handleCommands(params) {
+    if (HANDLERS === null) {
+        HANDLERS = [
+            // Plugin commands are processed first, before built-in commands
+            handlePluginCommand,
+            handleBashCommand,
+            handleActivationCommand,
+            handleSendPolicyCommand,
+            handleUsageCommand,
+            handleRestartCommand,
+            handleTtsCommands,
+            handleHelpCommand,
+            handleCommandsListCommand,
+            handleStatusCommand,
+            handleAllowlistCommand,
+            handleApproveCommand,
+            handleContextCommand,
+            handleWhoamiCommand,
+            handleSubagentsCommand,
+            handleConfigCommand,
+            handleDebugCommand,
+            handleModelsCommand,
+            handleStopCommand,
+            handleCompactCommand,
+            handleAbortTrigger,
+        ];
+    }
     const resetMatch = params.command.commandBodyNormalized.match(/^\/(new|reset)(?:\s|$)/);
     const resetRequested = Boolean(resetMatch);
     if (resetRequested && !params.command.isAuthorizedSender) {
@@ -83,8 +86,9 @@ export async function handleCommands(params) {
     });
     for (const handler of HANDLERS) {
         const result = await handler(params, allowTextCommands);
-        if (result)
+        if (result) {
             return result;
+        }
     }
     const sendPolicy = resolveSendPolicy({
         cfg: params.cfg,

package/dist/auto-reply/reply/commands-info.d.ts

@@ -0,0 +1,10 @@
+import type { CommandHandler } from "./commands-types.js";
+export declare const handleHelpCommand: CommandHandler;
+export declare const handleCommandsListCommand: CommandHandler;
+export declare function buildCommandsPaginationKeyboard(currentPage: number, totalPages: number, agentId?: string): Array<Array<{
+    text: string;
+    callback_data: string;
+}>>;
+export declare const handleStatusCommand: CommandHandler;
+export declare const handleContextCommand: CommandHandler;
+export declare const handleWhoamiCommand: CommandHandler;

package/dist/auto-reply/reply/commands-info.js

@@ -1,13 +1,15 @@
 import { logVerbose } from "../../globals.js";
 import { listSkillCommandsForAgents } from "../skill-commands.js";
 import { buildCommandsMessage, buildCommandsMessagePaginated, buildHelpMessage, } from "../status.js";
-import { buildStatusReply } from "./commands-status.js";
 import { buildContextReply } from "./commands-context-report.js";
+import { buildStatusReply } from "./commands-status.js";
 export const handleHelpCommand = async (params, allowTextCommands) => {
-    if (!allowTextCommands)
+    if (!allowTextCommands) {
         return null;
-    if (params.command.commandBodyNormalized !== "/help")
+    }
+    if (params.command.commandBodyNormalized !== "/help") {
         return null;
+    }
     if (!params.command.isAuthorizedSender) {
         logVerbose(`Ignoring /help from unauthorized sender: ${params.command.senderId || "<unknown>"}`);
         return { shouldContinue: false };
@@ -18,10 +20,12 @@ export const handleHelpCommand = async (params, allowTextCommands) => {
     };
 };
 export const handleCommandsListCommand = async (params, allowTextCommands) => {
-    if (!allowTextCommands)
+    if (!allowTextCommands) {
         return null;
-    if (params.command.commandBodyNormalized !== "/commands")
+    }
+    if (params.command.commandBodyNormalized !== "/commands") {
         return null;
+    }
     if (!params.command.isAuthorizedSender) {
         logVerbose(`Ignoring /commands from unauthorized sender: ${params.command.senderId || "<unknown>"}`);
         return { shouldContinue: false };
@@ -82,11 +86,13 @@ export function buildCommandsPaginationKeyboard(currentPage, totalPages, agentId
     return [buttons];
 }
 export const handleStatusCommand = async (params, allowTextCommands) => {
-    if (!allowTextCommands)
+    if (!allowTextCommands) {
         return null;
+    }
     const statusRequested = params.directives.hasStatusDirective || params.command.commandBodyNormalized === "/status";
-    if (!statusRequested)
+    if (!statusRequested) {
         return null;
+    }
     if (!params.command.isAuthorizedSender) {
         logVerbose(`Ignoring /status from unauthorized sender: ${params.command.senderId || "<unknown>"}`);
         return { shouldContinue: false };
@@ -112,11 +118,13 @@ export const handleStatusCommand = async (params, allowTextCommands) => {
     return { shouldContinue: false, reply };
 };
 export const handleContextCommand = async (params, allowTextCommands) => {
-    if (!allowTextCommands)
+    if (!allowTextCommands) {
         return null;
+    }
     const normalized = params.command.commandBodyNormalized;
-    if (normalized !== "/context" && !normalized.startsWith("/context "))
+    if (normalized !== "/context" && !normalized.startsWith("/context ")) {
         return null;
+    }
     if (!params.command.isAuthorizedSender) {
         logVerbose(`Ignoring /context from unauthorized sender: ${params.command.senderId || "<unknown>"}`);
         return { shouldContinue: false };
@@ -124,10 +132,12 @@ export const handleContextCommand = async (params, allowTextCommands) => {
     return { shouldContinue: false, reply: await buildContextReply(params) };
 };
 export const handleWhoamiCommand = async (params, allowTextCommands) => {
-    if (!allowTextCommands)
+    if (!allowTextCommands) {
         return null;
-    if (params.command.commandBodyNormalized !== "/whoami")
+    }
+    if (params.command.commandBodyNormalized !== "/whoami") {
         return null;
+    }
     if (!params.command.isAuthorizedSender) {
         logVerbose(`Ignoring /whoami from unauthorized sender: ${params.command.senderId || "<unknown>"}`);
         return { shouldContinue: false };
@@ -135,8 +145,9 @@ export const handleWhoamiCommand = async (params, allowTextCommands) => {
     const senderId = params.ctx.SenderId ?? "";
     const senderUsername = params.ctx.SenderUsername ?? "";
     const lines = ["🧭 Identity", `Channel: ${params.command.channel}`];
-    if (senderId)
+    if (senderId) {
         lines.push(`User id: ${senderId}`);
+    }
     if (senderUsername) {
         const handle = senderUsername.startsWith("@") ? senderUsername : `@${senderUsername}`;
         lines.push(`Username: ${handle}`);

package/dist/auto-reply/reply/commands-models.d.ts

@@ -0,0 +1,8 @@
+import type { OpenClawConfig } from "../../config/config.js";
+import type { ReplyPayload } from "../types.js";
+import type { CommandHandler } from "./commands-types.js";
+export declare function resolveModelsCommandReply(params: {
+    cfg: OpenClawConfig;
+    commandBodyNormalized: string;
+}): Promise<ReplyPayload | null>;
+export declare const handleModelsCommand: CommandHandler;

package/dist/auto-reply/reply/commands-models.js

@@ -1,6 +1,6 @@
+import { DEFAULT_MODEL, DEFAULT_PROVIDER } from "../../agents/defaults.js";
 import { loadModelCatalog } from "../../agents/model-catalog.js";
 import { buildAllowedModelSet, buildModelAliasIndex, normalizeProviderId, resolveConfiguredModelRef, resolveModelRefFromString, } from "../../agents/model-selection.js";
-import { DEFAULT_MODEL, DEFAULT_PROVIDER } from "../../agents/defaults.js";
 const PAGE_SIZE_DEFAULT = 20;
 const PAGE_SIZE_MAX = 100;
 function formatProviderLine(params) {
@@ -23,14 +23,16 @@ function parseModelsArgs(raw) {
         }
         if (lower.startsWith("page=")) {
             const value = Number.parseInt(lower.slice("page=".length), 10);
-            if (Number.isFinite(value) && value > 0)
+            if (Number.isFinite(value) && value > 0) {
                 page = value;
+            }
             continue;
         }
         if (/^[0-9]+$/.test(lower)) {
             const value = Number.parseInt(lower, 10);
-            if (Number.isFinite(value) && value > 0)
+            if (Number.isFinite(value) && value > 0) {
                 page = value;
+            }
         }
     }
     let pageSize = PAGE_SIZE_DEFAULT;
@@ -39,8 +41,9 @@ function parseModelsArgs(raw) {
         if (lower.startsWith("limit=") || lower.startsWith("size=")) {
             const rawValue = lower.slice(lower.indexOf("=") + 1);
             const value = Number.parseInt(rawValue, 10);
-            if (Number.isFinite(value) && value > 0)
+            if (Number.isFinite(value) && value > 0) {
                 pageSize = Math.min(PAGE_SIZE_MAX, value);
+            }
         }
     }
     return {
@@ -52,8 +55,9 @@ function parseModelsArgs(raw) {
 }
 export async function resolveModelsCommandReply(params) {
     const body = params.commandBodyNormalized.trim();
-    if (!body.startsWith("/models"))
+    if (!body.startsWith("/models")) {
         return null;
+    }
     const argText = body.replace(/^\/models\b/i, "").trim();
     const { provider, page, pageSize, all } = parseModelsArgs(argText);
     const resolvedDefault = resolveConfiguredModelRef({
@@ -81,15 +85,17 @@ export async function resolveModelsCommandReply(params) {
     };
     const addRawModelRef = (raw) => {
         const trimmed = raw?.trim();
-        if (!trimmed)
+        if (!trimmed) {
             return;
+        }
         const resolved = resolveModelRefFromString({
             raw: trimmed,
             defaultProvider: resolvedDefault.provider,
             aliasIndex,
         });
-        if (!resolved)
+        if (!resolved) {
             return;
+        }
         add(resolved.ref.provider, resolved.ref.model);
     };
     const addModelConfigEntries = () => {
@@ -125,7 +131,7 @@ export async function resolveModelsCommandReply(params) {
     // curated catalog doesn't know about them (custom providers, dev builds, etc.).
     add(resolvedDefault.provider, resolvedDefault.model);
     addModelConfigEntries();
-    const providers = [...byProvider.keys()].sort();
+    const providers = [...byProvider.keys()].toSorted();
     if (!provider) {
         const lines = [
             "Providers:",
@@ -147,7 +153,7 @@ export async function resolveModelsCommandReply(params) {
         ];
         return { text: lines.join("\n") };
     }
-    const models = [...(byProvider.get(provider) ?? new Set())].sort();
+    const models = [...(byProvider.get(provider) ?? new Set())].toSorted();
     const total = models.length;
     if (total === 0) {
         const lines = [
@@ -189,13 +195,15 @@ export async function resolveModelsCommandReply(params) {
     return payload;
 }
 export const handleModelsCommand = async (params, allowTextCommands) => {
-    if (!allowTextCommands)
+    if (!allowTextCommands) {
         return null;
+    }
     const reply = await resolveModelsCommandReply({
         cfg: params.cfg,
         commandBodyNormalized: params.command.commandBodyNormalized,
     });
-    if (!reply)
+    if (!reply) {
         return null;
+    }
     return { reply, shouldContinue: false };
 };

package/dist/auto-reply/reply/commands-plugin.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Plugin Command Handler
+ *
+ * Handles commands registered by plugins, bypassing the LLM agent.
+ * This handler is called before built-in command handlers.
+ */
+import type { CommandHandler } from "./commands-types.js";
+/**
+ * Handle plugin-registered commands.
+ * Returns a result if a plugin command was matched and executed,
+ * or null to continue to the next handler.
+ */
+export declare const handlePluginCommand: CommandHandler;

package/dist/auto-reply/reply/commands-plugin.js

@@ -12,12 +12,14 @@ import { matchPluginCommand, executePluginCommand } from "../../plugins/commands
  */
 export const handlePluginCommand = async (params, allowTextCommands) => {
     const { command, cfg } = params;
-    if (!allowTextCommands)
+    if (!allowTextCommands) {
         return null;
+    }
     // Try to match a plugin command
     const match = matchPluginCommand(command.commandBodyNormalized);
-    if (!match)
+    if (!match) {
         return null;
+    }
     // Execute the plugin command (always returns a result)
     const result = await executePluginCommand({
         command: match.command,

package/dist/auto-reply/reply/commands-session.d.ts

@@ -0,0 +1,7 @@
+import type { CommandHandler } from "./commands-types.js";
+export declare const handleActivationCommand: CommandHandler;
+export declare const handleSendPolicyCommand: CommandHandler;
+export declare const handleUsageCommand: CommandHandler;
+export declare const handleRestartCommand: CommandHandler;
+export declare const handleStopCommand: CommandHandler;
+export declare const handleAbortTrigger: CommandHandler;

package/dist/auto-reply/reply/commands-session.js

@@ -2,27 +2,30 @@ import { abortEmbeddedPiRun } from "../../agents/pi-embedded.js";
 import { updateSessionStore } from "../../config/sessions.js";
 import { logVerbose } from "../../globals.js";
 import { createInternalHookEvent, triggerInternalHook } from "../../hooks/internal-hooks.js";
-import { scheduleGatewaySigusr1Restart, triggerMoltbotRestart } from "../../infra/restart.js";
+import { scheduleGatewaySigusr1Restart, triggerOpenClawRestart } from "../../infra/restart.js";
+import { loadCostUsageSummary, loadSessionCostSummary } from "../../infra/session-cost-usage.js";
+import { formatTokenCount, formatUsd } from "../../utils/usage-format.js";
 import { parseActivationCommand } from "../group-activation.js";
 import { parseSendPolicyCommand } from "../send-policy.js";
 import { normalizeUsageDisplay, resolveResponseUsageMode } from "../thinking.js";
-import { loadCostUsageSummary, loadSessionCostSummary } from "../../infra/session-cost-usage.js";
-import { formatTokenCount, formatUsd } from "../../utils/usage-format.js";
 import { formatAbortReplyText, isAbortTrigger, setAbortMemory, stopSubagentsForRequester, } from "./abort.js";
 import { clearSessionQueues } from "./queue.js";
 function resolveSessionEntryForKey(store, sessionKey) {
-    if (!store || !sessionKey)
+    if (!store || !sessionKey) {
         return {};
+    }
     const direct = store[sessionKey];
-    if (direct)
+    if (direct) {
         return { entry: direct, key: sessionKey };
+    }
     return {};
 }
 function resolveAbortTarget(params) {
     const targetSessionKey = params.ctx.CommandTargetSessionKey?.trim() || params.sessionKey;
     const { entry, key } = resolveSessionEntryForKey(params.sessionStore, targetSessionKey);
-    if (entry && key)
+    if (entry && key) {
         return { entry, key, sessionId: entry.sessionId };
+    }
     if (params.sessionEntry && params.sessionKey) {
         return {
             entry: params.sessionEntry,
@@ -33,11 +36,13 @@ function resolveAbortTarget(params) {
     return { entry: undefined, key: targetSessionKey, sessionId: undefined };
 }
 export const handleActivationCommand = async (params, allowTextCommands) => {
-    if (!allowTextCommands)
+    if (!allowTextCommands) {
         return null;
+    }
     const activationCommand = parseActivationCommand(params.command.commandBodyNormalized);
-    if (!activationCommand.hasCommand)
+    if (!activationCommand.hasCommand) {
         return null;
+    }
     if (!params.isGroup) {
         return {
             shouldContinue: false,
@@ -73,11 +78,13 @@ export const handleActivationCommand = async (params, allowTextCommands) => {
     };
 };
 export const handleSendPolicyCommand = async (params, allowTextCommands) => {
-    if (!allowTextCommands)
+    if (!allowTextCommands) {
         return null;
+    }
     const sendPolicyCommand = parseSendPolicyCommand(params.command.commandBodyNormalized);
-    if (!sendPolicyCommand.hasCommand)
+    if (!sendPolicyCommand.hasCommand) {
         return null;
+    }
     if (!params.command.isAuthorizedSender) {
         logVerbose(`Ignoring /send from unauthorized sender: ${params.command.senderId || "<unknown>"}`);
         return { shouldContinue: false };
@@ -114,11 +121,13 @@ export const handleSendPolicyCommand = async (params, allowTextCommands) => {
     };
 };
 export const handleUsageCommand = async (params, allowTextCommands) => {
-    if (!allowTextCommands)
+    if (!allowTextCommands) {
         return null;
+    }
     const normalized = params.command.commandBodyNormalized;
-    if (normalized !== "/usage" && !normalized.startsWith("/usage "))
+    if (normalized !== "/usage" && !normalized.startsWith("/usage ")) {
         return null;
+    }
     if (!params.command.isAuthorizedSender) {
         logVerbose(`Ignoring /usage from unauthorized sender: ${params.command.senderId || "<unknown>"}`);
         return { shouldContinue: false };
@@ -168,10 +177,12 @@ export const handleUsageCommand = async (params, allowTextCommands) => {
     const current = resolveResponseUsageMode(currentRaw);
     const next = requested ?? (current === "off" ? "tokens" : current === "tokens" ? "full" : "off");
     if (params.sessionEntry && params.sessionStore && params.sessionKey) {
-        if (next === "off")
+        if (next === "off") {
             delete params.sessionEntry.responseUsage;
-        else
+        }
+        else {
             params.sessionEntry.responseUsage = next;
+        }
         params.sessionEntry.updatedAt = Date.now();
         params.sessionStore[params.sessionKey] = params.sessionEntry;
         if (params.storePath) {
@@ -188,10 +199,12 @@ export const handleUsageCommand = async (params, allowTextCommands) => {
     };
 };
 export const handleRestartCommand = async (params, allowTextCommands) => {
-    if (!allowTextCommands)
+    if (!allowTextCommands) {
         return null;
-    if (params.command.commandBodyNormalized !== "/restart")
+    }
+    if (params.command.commandBodyNormalized !== "/restart") {
         return null;
+    }
     if (!params.command.isAuthorizedSender) {
         logVerbose(`Ignoring /restart from unauthorized sender: ${params.command.senderId || "<unknown>"}`);
         return { shouldContinue: false };
@@ -210,11 +223,11 @@ export const handleRestartCommand = async (params, allowTextCommands) => {
         return {
             shouldContinue: false,
             reply: {
-                text: "⚙️ Restarting moltbot in-process (SIGUSR1); back in a few seconds.",
+                text: "⚙️ Restarting OpenClaw in-process (SIGUSR1); back in a few seconds.",
             },
         };
     }
-    const restartMethod = triggerMoltbotRestart();
+    const restartMethod = triggerOpenClawRestart();
     if (!restartMethod.ok) {
         const detail = restartMethod.detail ? ` Details: ${restartMethod.detail}` : "";
         return {
@@ -227,15 +240,17 @@ export const handleRestartCommand = async (params, allowTextCommands) => {
     return {
         shouldContinue: false,
         reply: {
-            text: `⚙️ Restarting moltbot via ${restartMethod.method}; give me a few seconds to come back online.`,
+            text: `⚙️ Restarting OpenClaw via ${restartMethod.method}; give me a few seconds to come back online.`,
         },
     };
 };
 export const handleStopCommand = async (params, allowTextCommands) => {
-    if (!allowTextCommands)
+    if (!allowTextCommands) {
         return null;
-    if (params.command.commandBodyNormalized !== "/stop")
+    }
+    if (params.command.commandBodyNormalized !== "/stop") {
         return null;
+    }
     if (!params.command.isAuthorizedSender) {
         logVerbose(`Ignoring /stop from unauthorized sender: ${params.command.senderId || "<unknown>"}`);
         return { shouldContinue: false };
@@ -281,10 +296,12 @@ export const handleStopCommand = async (params, allowTextCommands) => {
     return { shouldContinue: false, reply: { text: formatAbortReplyText(stopped) } };
 };
 export const handleAbortTrigger = async (params, allowTextCommands) => {
-    if (!allowTextCommands)
+    if (!allowTextCommands) {
         return null;
-    if (!isAbortTrigger(params.command.rawBodyNormalized))
+    }
+    if (!isAbortTrigger(params.command.rawBodyNormalized)) {
         return null;
+    }
     const abortTarget = resolveAbortTarget({
         ctx: params.ctx,
         sessionKey: params.sessionKey,

package/dist/auto-reply/reply/commands-status.d.ts

@@ -0,0 +1,24 @@
+import type { OpenClawConfig } from "../../config/config.js";
+import type { SessionEntry, SessionScope } from "../../config/sessions.js";
+import type { MediaUnderstandingDecision } from "../../media-understanding/types.js";
+import type { ElevatedLevel, ReasoningLevel, ThinkLevel, VerboseLevel } from "../thinking.js";
+import type { ReplyPayload } from "../types.js";
+import type { CommandContext } from "./commands-types.js";
+export declare function buildStatusReply(params: {
+    cfg: OpenClawConfig;
+    command: CommandContext;
+    sessionEntry?: SessionEntry;
+    sessionKey: string;
+    sessionScope?: SessionScope;
+    provider: string;
+    model: string;
+    contextTokens: number;
+    resolvedThinkLevel?: ThinkLevel;
+    resolvedVerboseLevel: VerboseLevel;
+    resolvedReasoningLevel: ReasoningLevel;
+    resolvedElevatedLevel?: ElevatedLevel;
+    resolveDefaultThinkingLevel: () => Promise<ThinkLevel | undefined>;
+    isGroup: boolean;
+    defaultGroupActivation: () => "always" | "mention";
+    mediaDecisions?: MediaUnderstandingDecision[];
+}): Promise<ReplyPayload | undefined>;

package/dist/auto-reply/reply/commands-status.js

@@ -1,9 +1,9 @@
 import { resolveAgentDir, resolveDefaultAgentId, resolveSessionAgentId, } from "../../agents/agent-scope.js";
-import { listSubagentRunsForRequester } from "../../agents/subagent-registry.js";
 import { ensureAuthProfileStore, resolveAuthProfileDisplayLabel, resolveAuthProfileOrder, } from "../../agents/auth-profiles.js";
 import { getCustomProviderApiKey, resolveEnvApiKey } from "../../agents/model-auth.js";
-import { resolveInternalSessionKey, resolveMainSessionAlias, } from "../../agents/tools/sessions-helpers.js";
 import { normalizeProviderId } from "../../agents/model-selection.js";
+import { listSubagentRunsForRequester } from "../../agents/subagent-registry.js";
+import { resolveInternalSessionKey, resolveMainSessionAlias, } from "../../agents/tools/sessions-helpers.js";
 import { logVerbose } from "../../globals.js";
 import { formatUsageWindowSummary, loadProviderUsageSummary, resolveUsageProviderId, } from "../../infra/provider-usage.js";
 import { normalizeGroupActivation } from "../group-activation.js";
@@ -12,8 +12,9 @@ import { getFollowupQueueDepth, resolveQueueSettings } from "./queue.js";
 import { resolveSubagentLabel } from "./subagents-utils.js";
 function formatApiKeySnippet(apiKey) {
     const compact = apiKey.replace(/\s+/g, "");
-    if (!compact)
+    if (!compact) {
         return "unknown";
+    }
     const edge = compact.length >= 12 ? 6 : 4;
     const head = compact.slice(0, edge);
     const tail = compact.slice(-edge);
@@ -21,8 +22,9 @@ function formatApiKeySnippet(apiKey) {
 }
 function resolveModelAuthLabel(provider, cfg, sessionEntry, agentDir) {
     const resolved = provider?.trim();
-    if (!resolved)
+    if (!resolved) {
         return undefined;
+    }
     const providerKey = normalizeProviderId(resolved);
     const store = ensureAuthProfileStore(agentDir, {
         allowKeychainPrompt: false,
@@ -97,8 +99,9 @@ export async function buildStatusReply(params) {
                     maxWindows: 2,
                     includeResets: true,
                 });
-                if (summaryLine)
+                if (summaryLine) {
                     usageLine = `📊 Usage: ${summaryLine}`;
+                }
             }
         }
         catch {

package/dist/auto-reply/reply/commands-subagents.d.ts

@@ -0,0 +1,13 @@
+import type { CommandHandler } from "./commands-types.js";
+type ChatMessage = {
+    role?: unknown;
+    content?: unknown;
+    name?: unknown;
+    toolName?: unknown;
+};
+export declare function extractMessageText(message: ChatMessage): {
+    role: string;
+    text: string;
+} | null;
+export declare const handleSubagentsCommand: CommandHandler;
+export {};