### Fixes

- Agents/skills: apply the full effective tool policy pipeline to inline `command-dispatch: tool` skill dispatch before owner-only filtering, preserving configured allow, deny, sandbox, sender, group, and subagent restrictions. (#78525)

- Channel accounts: keep top-level default channel accounts visible when named accounts are added alongside default credential material, so mixed legacy/new account configs keep resolving `default` instead of silently dropping it.

- Codex/Telegram: synthesize native Codex tool progress from final turn snapshots so Telegram `/verbose` stays visible when command events arrive only at completion.

- Mac app: make Channels settings open faster by deferring config-schema work, avoiding startup channel probes, caching decoded channel status rows, and showing only compact quick settings instead of the full generated channel schema.

- Control UI: include the Control UI and Gateway protocol versions in protocol-mismatch errors so stale app/dashboard pairings identify which side needs rebuilding or restarting.

import { describe, expect, it } from "vitest";

import { resolveClickClackAccount } from "./accounts.js";

import {

listClickClackAccountIds,

resolveClickClackAccount,

resolveDefaultClickClackAccountId,

} from "./accounts.js";

import type { CoreConfig } from "./types.js";

describe("ClickClack account resolution", () => {

it("preserves top-level default account when named accounts are configured", () => {

const cfg = {

channels: {

clickclack: {

baseUrl: "https://app.clickclack.chat",

workspace: "wsp_1",

token: "ccb_default",

accounts: {

work: { enabled: false },

},

},

},

} satisfies CoreConfig;

expect(listClickClackAccountIds(cfg)).toEqual(["default", "work"]);

expect(resolveDefaultClickClackAccountId(cfg)).toBe("default");

expect(resolveClickClackAccount({ cfg }).token).toBe("ccb_default");

});

it("does not synthesize a partial top-level default account from inherited credentials", () => {

const cfg = {

channels: {

clickclack: {

token: "ccb_shared",

accounts: {

work: {

baseUrl: "https://app.clickclack.chat",

workspace: "wsp_1",

},

},

},

},

} satisfies CoreConfig;

expect(listClickClackAccountIds(cfg)).toEqual(["work"]);

expect(resolveDefaultClickClackAccountId(cfg)).toBe("work");

});

it("does not synthesize a default account from blank top-level credentials", () => {

const cfg = {

channels: {

clickclack: {

baseUrl: "https://app.clickclack.chat",

workspace: "wsp_default",

token: " ",

accounts: {

work: {

baseUrl: "https://app.clickclack.chat",

workspace: "wsp_1",

token: "ccb_work",

},

},

},

},

} satisfies CoreConfig;

expect(listClickClackAccountIds(cfg)).toEqual(["work"]);

expect(resolveDefaultClickClackAccountId(cfg)).toBe("work");

});

it("resolves env SecretRefs at runtime", () => {

const cfg = {

channels: {

import { createAccountListHelpers } from "openclaw/plugin-sdk/account-helpers";

import {

createAccountListHelpers,

hasConfiguredAccountValue,

} from "openclaw/plugin-sdk/account-helpers";

import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/account-id";

import { resolveMergedAccountConfig } from "openclaw/plugin-sdk/account-resolution";

import { resolveDefaultSecretProviderAlias } from "openclaw/plugin-sdk/provider-auth";

const {

listAccountIds: listClickClackAccountIds,

resolveDefaultAccountId: resolveDefaultClickClackAccountId,

} = createAccountListHelpers("clickclack", { normalizeAccountId });

} = createAccountListHelpers("clickclack", {

normalizeAccountId,

hasImplicitDefaultAccount: (cfg) => {

const channel = cfg.channels?.clickclack;

return Boolean(

channel?.baseUrl?.trim() &&

hasConfiguredAccountValue(channel.token) &&

channel.workspace?.trim(),

);

},

});

export { DEFAULT_ACCOUNT_ID, listClickClackAccountIds, resolveDefaultClickClackAccountId };

import {

createDiscordActionGate,

isDiscordAccountEnabledForRuntime,

listDiscordAccountIds,

listEnabledDiscordAccounts,

resolveDefaultDiscordAccountId,

resolveDiscordAccount,

resolveDiscordAccountDisabledReason,

resolveDiscordMaxLinesPerMessage,

assert();

},

);

it("keeps the implicit default account when named accounts are added to top-level credentials", () => {

const cfg = {

channels: {

discord: {

token: "token-default",

accounts: {

work: {

enabled: false,

token: "token-work",

},

},

},

},

} as OpenClawConfig;

expect(listDiscordAccountIds(cfg)).toEqual(["default", "work"]);

expect(resolveDefaultDiscordAccountId(cfg)).toBe("default");

expect(listEnabledDiscordAccounts(cfg).map((account) => account.accountId)).toEqual([

"default",

]);

});

});

describe("resolveDiscordAccount allowFrom precedence", () => {

config: DiscordAccountConfig;

};

const { listAccountIds, resolveDefaultAccountId } = createAccountListHelpers("discord");

const { listAccountIds, resolveDefaultAccountId } = createAccountListHelpers("discord", {

implicitDefaultAccount: {

channelKeys: ["token"],

envVars: ["DISCORD_BOT_TOKEN"],

},

});

export const listDiscordAccountIds = listAccountIds;

export const resolveDefaultDiscordAccountId = resolveDefaultAccountId;

import {

FeishuSecretRefUnavailableError,

inspectFeishuCredentials,

listFeishuAccountIds,

resolveDefaultFeishuAccountId,

resolveDefaultFeishuAccountSelection,

resolveFeishuAccount,

}

describe("resolveDefaultFeishuAccountId", () => {

it("preserves top-level default account when named accounts are configured", () => {

const cfg = {

channels: {

feishu: {

appId: "cli_default",

appSecret: "secret_default",

accounts: {

work: { enabled: false },

},

},

},

};

expect(listFeishuAccountIds(cfg as never)).toEqual(["default", "work"]);

expect(resolveDefaultFeishuAccountId(cfg as never)).toBe("default");

});

it("prefers channels.feishu.defaultAccount when configured", () => {

const cfg = {

channels: {

DEFAULT_ACCOUNT_ID,

type OpenClawConfig as ClawdbotConfig,

createAccountListHelpers,

hasConfiguredAccountValue,

normalizeAccountId,

normalizeOptionalAccountId,

resolveMergedAccountConfig,

"feishu",

{

allowUnlistedDefaultAccount: true,

hasImplicitDefaultAccount: (cfg) =>

Boolean(

cfg.channels?.feishu?.appId?.trim() &&

hasConfiguredAccountValue(cfg.channels.feishu.appSecret),

),

},

);

const {

listAccountIds: listGoogleChatAccountIds,

resolveDefaultAccountId: resolveDefaultGoogleChatAccountId,

} = createAccountListHelpers("googlechat");

} = createAccountListHelpers("googlechat", {

implicitDefaultAccount: {

channelKeys: ["serviceAccount", "serviceAccountRef", "serviceAccountFile"],

envVars: [ENV_SERVICE_ACCOUNT, ENV_SERVICE_ACCOUNT_FILE],

},

});

export { listGoogleChatAccountIds, resolveDefaultGoogleChatAccountId };

function mergeGoogleChatAccountConfig(

import { describe, expect, it } from "vitest";

import { resolveIMessageAccount } from "./accounts.js";

import {

listIMessageAccountIds,

resolveDefaultIMessageAccountId,

resolveIMessageAccount,

} from "./accounts.js";

describe("resolveIMessageAccount", () => {

it("preserves top-level default account when named accounts are configured", () => {

const cfg = {

channels: {

imessage: {

cliPath: "/usr/local/bin/imsg",

accounts: {

work: { enabled: false },

},

},

},

} as never;

expect(listIMessageAccountIds(cfg)).toEqual(["default", "work"]);

expect(resolveDefaultIMessageAccountId(cfg)).toBe("default");

expect(resolveIMessageAccount({ cfg }).config.cliPath).toBe("/usr/local/bin/imsg");

});

it("uses configured defaultAccount when accountId is omitted", () => {

const resolved = resolveIMessageAccount({

cfg: {

configured: boolean;

};

const { listAccountIds, resolveDefaultAccountId } = createAccountListHelpers("imessage");

const { listAccountIds, resolveDefaultAccountId } = createAccountListHelpers("imessage", {

implicitDefaultAccount: {

channelKeys: ["cliPath", "dbPath"],

},

});

export const listIMessageAccountIds = listAccountIds;

export const resolveDefaultIMessageAccountId = resolveDefaultAccountId;